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

test/cctest/test-debug.cc

 // Copyright 2007-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 358 matching lines @@
   v8::internal::RelocIterator* it_original() {
     return reloc_iterator_original_;
   }
 };
 
 
 // Compile a function, set a break point and check that the call at the break
 // location in the code is the expected debug_break function.
 void CheckDebugBreakFunction(DebugLocalContext* env,
                              const char* source, const char* name,
-                             int position, v8::internal::RelocMode mode,
+                             int position, v8::internal::RelocInfo::Mode mode,
                              Code* debug_break) {
   // Create function and set the break point.
   Handle<v8::internal::JSFunction> fun = v8::Utils::OpenHandle(
       *CompileFunction(env, source, name));
   int bp = SetBreakPoint(fun, position);
 
   // Check that the debug break function is as expected.
   Handle<v8::internal::SharedFunctionInfo> shared(fun->shared());
   CHECK(Debug::HasDebugInfo(shared));
   TestBreakLocationIterator it1(Debug::GetDebugInfo(shared));
   it1.FindBreakLocationFromPosition(position);
   CHECK_EQ(mode, it1.it()->rinfo()->rmode());
-  if (mode != v8::internal::js_return) {
+  if (mode != v8::internal::RelocInfo::JS_RETURN) {
     CHECK_EQ(debug_break,
              Debug::GetCodeTarget(it1.it()->rinfo()->target_address()));
   } else {
     // TODO(1240753): Make the test architecture independent or split
     // parts of the debugger into architecture dependent files.
     CHECK_EQ(0xE8, *(it1.rinfo()->pc()));
   }
 
   // Clear the break point and check that the debug break function is no longer
   // there
   ClearBreakPoint(bp);
   CHECK(!Debug::HasDebugInfo(shared));
   CHECK(Debug::EnsureDebugInfo(shared));
   TestBreakLocationIterator it2(Debug::GetDebugInfo(shared));
   it2.FindBreakLocationFromPosition(position);
   CHECK_EQ(mode, it2.it()->rinfo()->rmode());
-  if (mode == v8::internal::js_return) {
+  if (mode == v8::internal::RelocInfo::JS_RETURN) {
     // TODO(1240753): Make the test architecture independent or split
     // parts of the debugger into architecture dependent files.
     CHECK_NE(0xE8, *(it2.rinfo()->pc()));
   }
 }
 
 
 // --- D e b u g   E v e n t   H a n d l e r s
 // ---
 // --- The different tests uses a number of debug event handlers.
@@ skipping 240 matching lines @@
 // --- T h e   A c t u a l   T e s t s
 
 
 // Test that the debug break function is the expected one for different kinds
 // of break locations.
 TEST(DebugStub) {
   using ::v8::internal::Builtins;
   v8::HandleScope scope;
   DebugLocalContext env;
 
-  // TODO(1240753): Make the test architecture independent or split
-  // parts of the debugger into architecture dependent files. This
-  // part currently disabled as it is not portable between IA32/ARM.
-  // Ia32 uses js_return ARM uses exit_js_frame.
-#if !defined (__arm__) && !defined(__thumb__)
   CheckDebugBreakFunction(&env,
                           "function f1(){}", "f1",
                           0,
-                          v8::internal::js_return,
+                          v8::internal::RelocInfo::JS_RETURN,
                           NULL);
-#endif
   CheckDebugBreakFunction(&env,
                           "function f2(){x=1;}", "f2",
                           0,
-                          v8::internal::code_target,
+                          v8::internal::RelocInfo::CODE_TARGET,
                           Builtins::builtin(Builtins::StoreIC_DebugBreak));
   CheckDebugBreakFunction(&env,
                           "function f3(){var a=x;}", "f3",
                           0,
-                          v8::internal::code_target_context,
+                          v8::internal::RelocInfo::CODE_TARGET_CONTEXT,
                           Builtins::builtin(Builtins::LoadIC_DebugBreak));
 
+// TODO(1240753): Make the test architecture independent or split
+// parts of the debugger into architecture dependent files. This
+// part currently disabled as it is not portable between IA32/ARM.
 // Currently on ICs for keyed store/load on ARM.
 #if !defined (__arm__) && !defined(__thumb__)
   CheckDebugBreakFunction(
       &env,
       "function f4(){var index='propertyName'; var a={}; a[index] = 'x';}",
       "f4",
       0,
-      v8::internal::code_target,
+      v8::internal::RelocInfo::CODE_TARGET,
       Builtins::builtin(Builtins::KeyedStoreIC_DebugBreak));
   CheckDebugBreakFunction(
       &env,
       "function f5(){var index='propertyName'; var a={}; return a[index];}",
       "f5",
       0,
-      v8::internal::code_target,
+      v8::internal::RelocInfo::CODE_TARGET,
       Builtins::builtin(Builtins::KeyedLoadIC_DebugBreak));
 #endif
 
   // Check the debug break code stubs for call ICs with different number of
   // parameters.
   Handle<Code> debug_break_0 = v8::internal::ComputeCallDebugBreak(0);
   Handle<Code> debug_break_1 = v8::internal::ComputeCallDebugBreak(1);
   Handle<Code> debug_break_4 = v8::internal::ComputeCallDebugBreak(4);
 
   CheckDebugBreakFunction(&env,
                           "function f4_0(){x();}", "f4_0",
                           0,
-                          v8::internal::code_target_context,
+                          v8::internal::RelocInfo::CODE_TARGET_CONTEXT,
                           *debug_break_0);
 
   CheckDebugBreakFunction(&env,
                           "function f4_1(){x(1);}", "f4_1",
                           0,
-                          v8::internal::code_target_context,
+                          v8::internal::RelocInfo::CODE_TARGET_CONTEXT,
                           *debug_break_1);
 
   CheckDebugBreakFunction(&env,
                           "function f4_4(){x(1,2,3,4);}", "f4_4",
                           0,
-                          v8::internal::code_target_context,
+                          v8::internal::RelocInfo::CODE_TARGET_CONTEXT,
                           *debug_break_4);
 }
 
 
 // Test that the debug info in the VM is in sync with the functions being
 // debugged.
 TEST(DebugInfo) {
   v8::HandleScope scope;
   DebugLocalContext env;
   // Create a couple of functions for the test.
@@ skipping 2379 matching lines @@
   Barriers stack_allocated_breakpoints_barriers;
   stack_allocated_breakpoints_barriers.Initialize();
   breakpoints_barriers = &stack_allocated_breakpoints_barriers;
 
   breakpoints_v8_thread.Start();
   breakpoints_debugger_thread.Start();
 
   breakpoints_v8_thread.Join();
   breakpoints_debugger_thread.Join();
 }