Refactor the enum RelocMode changing the naming scheme from lower case to...

src/debug.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 78 matching lines @@
   // Iterate through reloc info for code and original code stopping at each
   // breakable code target.
   bool first = break_point_ == -1;
   while (!RinfoDone()) {
     if (!first) RinfoNext();
     first = false;
     if (RinfoDone()) return;
 
     // Whenever a statement position or (plain) position is passed update the
     // current value of these.
-    if (is_position(rmode())) {
-      if (is_statement_position(rmode())) {
+    if (RelocInfo::IsPosition(rmode())) {
+      if (RelocInfo::IsStatementPosition(rmode())) {
         statement_position_ =
             rinfo()->data() - debug_info_->shared()->start_position();
       }
       // Always update the position as we don't want that to be before the
       // statement position.
       position_ = rinfo()->data() - debug_info_->shared()->start_position();
       ASSERT(position_ >= 0);
       ASSERT(statement_position_ >= 0);
     }
 
     // Check for breakable code target. Look in the original code as setting
     // break points can cause the code targets in the running (debugged) code to
     // be of a different kind than in the original code.
-    if (is_code_target(rmode())) {
+    if (RelocInfo::IsCodeTarget(rmode())) {
       Address target = original_rinfo()->target_address();
       Code* code = Debug::GetCodeTarget(target);
-      if (code->is_inline_cache_stub() || is_js_construct_call(rmode())) {
+      if (code->is_inline_cache_stub() || RelocInfo::IsConstructCall(rmode())) {
         break_point_++;
         return;
       }
       if (code->kind() == Code::STUB) {
         if (type_ == ALL_BREAK_LOCATIONS) {
           if (Debug::IsBreakStub(code)) {
             break_point_++;
             return;
           }
         } else {
           ASSERT(type_ == SOURCE_BREAK_LOCATIONS);
           if (Debug::IsSourceBreakStub(code)) {
             break_point_++;
             return;
           }
         }
       }
     }
 
     // Check for break at return.
-    // Currently is_exit_js_frame is used on ARM.
-    if (is_js_return(rmode()) || is_exit_js_frame(rmode())) {
+    if (RelocInfo::IsJSReturn(rmode())) {
       // Set the positions to the end of the function.
       if (debug_info_->shared()->HasSourceCode()) {
         position_ = debug_info_->shared()->end_position() -
                     debug_info_->shared()->start_position();
       } else {
         position_ = 0;
       }
       statement_position_ = position_;
       break_point_++;
       return;
@@ skipping 128 matching lines @@
 
 void BreakLocationIterator::SetDebugBreak() {
   // If there is already a break point here just return. This might happen if
   // the same code is flooded with break points twice. Flooding the same
   // function twice might happen when stepping in a function with an exception
   // handler as the handler and the function is the same.
   if (IsDebugBreak()) {
     return;
   }
 
-  if (is_js_return(rmode())) {
+  if (RelocInfo::IsJSReturn(rmode())) {
     // This path is currently only used on IA32 as JSExitFrame on ARM uses a
     // stub.
     // Patch the JS frame exit code with a debug break call. See
     // VisitReturnStatement and ExitJSFrame in codegen-ia32.cc for the
     // precise return instructions sequence.
     ASSERT(Debug::kIa32JSReturnSequenceLength >=
            Debug::kIa32CallInstructionLength);
     rinfo()->patch_code_with_call(Debug::debug_break_return_entry()->entry(),
         Debug::kIa32JSReturnSequenceLength - Debug::kIa32CallInstructionLength);
   } else {
     // Patch the original code with the current address as the current address
     // might have changed by the inline caching since the code was copied.
     original_rinfo()->set_target_address(rinfo()->target_address());
 
     // Patch the code to invoke the builtin debug break function matching the
     // calling convention used by the call site.
     Handle<Code> dbgbrk_code(Debug::FindDebugBreak(rinfo()));
     rinfo()->set_target_address(dbgbrk_code->entry());
   }
   ASSERT(IsDebugBreak());
 }
 
 
 void BreakLocationIterator::ClearDebugBreak() {
-  if (is_js_return(rmode())) {
+  if (RelocInfo::IsJSReturn(rmode())) {
     // Restore the JS frame exit code.
     rinfo()->patch_code(original_rinfo()->pc(),
                         Debug::kIa32JSReturnSequenceLength);
   } else {
     // Patch the code to the original invoke.
     rinfo()->set_target_address(original_rinfo()->target_address());
   }
   ASSERT(!IsDebugBreak());
 }
 
@@ skipping 10 matching lines @@
     // the call in the original code as it is the code there that will be
     // executed in place of the debug break call.
     Handle<Code> stub = ComputeCallDebugPrepareStepIn(code->arguments_count());
     if (IsDebugBreak()) {
       original_rinfo()->set_target_address(stub->entry());
     } else {
       rinfo()->set_target_address(stub->entry());
     }
   } else {
     // Step in through constructs call requires no changes to the running code.
-    ASSERT(is_js_construct_call(rmode()));
+    ASSERT(RelocInfo::IsConstructCall(rmode()));
   }
 }
 
 
 // Check whether the break point is at a position which will exit the function.
 bool BreakLocationIterator::IsExit() const {
-  // Currently is_exit_js_frame is used on ARM.
-  return (is_js_return(rmode()) || is_exit_js_frame(rmode()));
+  return (RelocInfo::IsJSReturn(rmode()));
 }
 
 
 bool BreakLocationIterator::HasBreakPoint() {
   return debug_info_->HasBreakPoint(code_position());
 }
 
 
 // Check whether there is a debug break at the current position.
 bool BreakLocationIterator::IsDebugBreak() {
-  if (is_js_return(rmode())) {
+  if (RelocInfo::IsJSReturn(rmode())) {
     // This is IA32 specific but works as long as the ARM version
     // still uses a stub for JSExitFrame.
     //
     // TODO(1240753): Make the test architecture independent or split
     // parts of the debugger into architecture dependent files.
     return (*(rinfo()->pc()) == 0xE8);
   } else {
     return Debug::IsDebugBreak(rinfo()->target_address());
   }
 }
@@ skipping 22 matching lines @@
 }
 
 
 bool Debug::has_break_points_ = false;
 DebugInfoListNode* Debug::debug_info_list_ = NULL;
 
 
 // Threading support.
 void Debug::ThreadInit() {
   thread_local_.last_step_action_ = StepNone;
-  thread_local_.last_statement_position_ = kNoPosition;
+  thread_local_.last_statement_position_ = RelocInfo::kNoPosition;
   thread_local_.step_count_ = 0;
   thread_local_.last_fp_ = 0;
   thread_local_.step_into_fp_ = 0;
   thread_local_.after_break_target_ = 0;
 }
 
 
 JSCallerSavedBuffer Debug::registers_;
 Debug::ThreadLocal Debug::thread_local_;
 
@@ skipping 497 matching lines @@
     return;
   }
   Handle<DebugInfo> debug_info = GetDebugInfo(shared);
 
   // Find the break location where execution has stopped.
   BreakLocationIterator it(debug_info, ALL_BREAK_LOCATIONS);
   it.FindBreakLocationFromAddress(frame->pc());
 
   // Compute whether or not the target is a call target.
   bool is_call_target = false;
-  if (is_code_target(it.rinfo()->rmode())) {
+  if (RelocInfo::IsCodeTarget(it.rinfo()->rmode())) {
     Address target = it.rinfo()->target_address();
     Code* code = Debug::GetCodeTarget(target);
     if (code->is_call_stub()) is_call_target = true;
   }
 
   // If this is the last break code target step out is the only possibility.
   if (it.IsExit() || step_action == StepOut) {
     // Step out: If there is a JavaScript caller frame, we need to
     // flood it with breakpoints.
     frames_it.Advance();
     if (!frames_it.done()) {
       // Fill the function to return to with one-shot break points.
       JSFunction* function = JSFunction::cast(frames_it.frame()->function());
       FloodWithOneShot(Handle<SharedFunctionInfo>(function->shared()));
     }
-  } else if (!(is_call_target || is_js_construct_call(it.rmode())) ||
+  } else if (!(is_call_target || RelocInfo::IsConstructCall(it.rmode())) ||
              step_action == StepNext || step_action == StepMin) {
     // Step next or step min.
 
     // Fill the current function with one-shot break points.
     FloodWithOneShot(shared);
 
     // Remember source position and frame to handle step next.
     thread_local_.last_statement_position_ =
         debug_info->code()->SourceStatementPosition(frame->pc());
     thread_local_.last_fp_ = frame->fp();
@@ skipping 59 matching lines @@
   CodeStub::Major major_key = code->major_key();
   return major_key == CodeStub::CallFunction ||
          major_key == CodeStub::StackCheck;
 }
 
 
 // Find the builtin to use for invoking the debug break
 Handle<Code> Debug::FindDebugBreak(RelocInfo* rinfo) {
   // Find the builtin debug break function matching the calling convention
   // used by the call site.
-  RelocMode mode = rinfo->rmode();
+  RelocInfo::Mode mode = rinfo->rmode();
 
-  if (is_code_target(mode)) {
+  if (RelocInfo::IsCodeTarget(mode)) {
     Address target = rinfo->target_address();
     Code* code = Debug::GetCodeTarget(target);
     if (code->is_inline_cache_stub()) {
       if (code->is_call_stub()) {
         return ComputeCallDebugBreak(code->arguments_count());
       }
       if (code->is_load_stub()) {
         return Handle<Code>(Builtins::builtin(Builtins::LoadIC_DebugBreak));
       }
       if (code->is_store_stub()) {
         return Handle<Code>(Builtins::builtin(Builtins::StoreIC_DebugBreak));
       }
       if (code->is_keyed_load_stub()) {
         Handle<Code> result =
             Handle<Code>(Builtins::builtin(Builtins::KeyedLoadIC_DebugBreak));
         return result;
       }
       if (code->is_keyed_store_stub()) {
         Handle<Code> result =
             Handle<Code>(Builtins::builtin(Builtins::KeyedStoreIC_DebugBreak));
         return result;
       }
     }
-    if (is_js_construct_call(mode)) {
+    if (RelocInfo::IsConstructCall(mode)) {
       Handle<Code> result =
           Handle<Code>(Builtins::builtin(Builtins::ConstructCall_DebugBreak));
       return result;
     }
-    // Currently is_exit_js_frame is used on ARM.
-    if (is_exit_js_frame(mode)) {
-      return Handle<Code>(Builtins::builtin(Builtins::Return_DebugBreak));
-    }
     if (code->kind() == Code::STUB) {
       ASSERT(code->major_key() == CodeStub::CallFunction ||
              code->major_key() == CodeStub::StackCheck);
       Handle<Code> result =
           Handle<Code>(Builtins::builtin(Builtins::StubNoRegisters_DebugBreak));
       return result;
     }
   }
 
   UNREACHABLE();
@@ skipping 60 matching lines @@
 }
 
 
 void Debug::ClearStepIn() {
   thread_local_.step_into_fp_ = 0;
 }
 
 
 void Debug::ClearStepNext() {
   thread_local_.last_step_action_ = StepNone;
-  thread_local_.last_statement_position_ = kNoPosition;
+  thread_local_.last_statement_position_ = RelocInfo::kNoPosition;
   thread_local_.last_fp_ = 0;
 }
 
 
 bool Debug::EnsureCompiled(Handle<SharedFunctionInfo> shared) {
   if (shared->is_compiled()) return true;
   return CompileLazyShared(shared, CLEAR_EXCEPTION);
 }
 
 
@@ skipping 69 matching lines @@
 
   // Find the call address in the running code. This address holds the call to
   // either a DebugBreakXXX or to the debug break return entry code if the
   // break point is still active after processing the break point.
   Address addr = frame->pc() - Assembler::kTargetAddrToReturnAddrDist;
 
   // Check if the location is at JS exit.
   bool at_js_exit = false;
   RelocIterator it(debug_info->code());
   while (!it.done()) {
-    if (is_js_return(it.rinfo()->rmode())) {
+    if (RelocInfo::IsJSReturn(it.rinfo()->rmode())) {
       at_js_exit = it.rinfo()->pc() == addr - 1;
     }
     it.next();
   }
 
   // Handle the jump to continue execution after break point depending on the
   // break location.
   if (at_js_exit) {
     // First check if the call in the code is still the debug break return
     // entry code. If it is the break point is still active. If not the break
@@ skipping 735 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal