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

src/builtins-ia32.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 248 matching lines @@
   __ mov(ecx, Operand(eax));
   __ jmp(&entry);
   __ bind(&loop);
   __ push(Operand(ebx, ecx, times_4, 0));
   __ bind(&entry);
   __ dec(ecx);
   __ j(greater_equal, &loop);
 
   // Call the function.
   Label return_site;
-  __ RecordPosition(position);
   ParameterCount actual(eax);
   __ InvokeFunction(edi, actual, CALL_FUNCTION);
   __ bind(&return_site);
 
   // Restore context from the frame.
   __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
 
   // If the result is an object (in the ECMA sense), we should get rid
   // of the receiver and use the result; see ECMA-262 section 13.2.2-7
   // on page 74.
@@ skipping 68 matching lines @@
   __ bind(&entry);
   __ cmp(ecx, Operand(eax));
   __ j(not_equal, &loop);
 
   // Get the function from the stack and call it.
   __ mov(edi, Operand(esp, eax, times_4, +1 * kPointerSize));  // +1 ~ receiver
 
   // Invoke the code.
   if (is_construct) {
     __ call(Handle<Code>(Builtins::builtin(Builtins::JSConstructCall)),
-            code_target);
+            RelocInfo::CODE_TARGET);
   } else {
     ParameterCount actual(eax);
     __ InvokeFunction(edi, actual, CALL_FUNCTION);
   }
 
   // Exit the JS frame. Notice that this also removes the empty
   // context and the function left on the stack by the code
   // invocation.
   __ ExitInternalFrame();
   __ ret(1 * kPointerSize);  // remove receiver
@@ skipping 114 matching lines @@
   __ dec(eax);
 
   // 6. Check that function really was a function and get the code to
   //    call from the function and check that the number of expected
   //    arguments matches what we're providing.
   { Label invoke;
     __ test(edi, Operand(edi));
     __ j(not_zero, &invoke, taken);
     __ xor_(ebx, Operand(ebx));
     __ GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION);
-    __ jmp(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)), code_target);
+    __ jmp(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)),
+           RelocInfo::CODE_TARGET);
 
     __ bind(&invoke);
     __ mov(edx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
     __ mov(ebx,
            FieldOperand(edx, SharedFunctionInfo::kFormalParameterCountOffset));
     __ mov(edx, FieldOperand(edx, SharedFunctionInfo::kCodeOffset));
     __ lea(edx, FieldOperand(edx, Code::kHeaderSize));
     __ cmp(eax, Operand(ebx));
     __ j(not_equal, Handle<Code>(builtin(ArgumentsAdaptorTrampoline)));
   }
@@ skipping 81 matching lines @@
   Label entry, loop;
   __ mov(eax, Operand(ebp, kIndexOffset));
   __ jmp(&entry);
   __ bind(&loop);
   __ mov(ecx, Operand(ebp, 2 * kPointerSize));  // load arguments
   __ push(ecx);
   __ push(eax);
 
   // Use inline caching to speed up access to arguments.
   Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
-  __ call(ic, code_target);
+  __ call(ic, RelocInfo::CODE_TARGET);
 
   // Remove IC arguments from the stack and push the nth argument.
   __ add(Operand(esp), Immediate(2 * kPointerSize));
   __ push(eax);
 
   // Update the index on the stack and in register eax.
   __ mov(eax, Operand(ebp, kIndexOffset));
   __ add(Operand(eax), Immediate(1 << kSmiTagSize));
   __ mov(Operand(ebp, kIndexOffset), eax);
 
@@ skipping 270 matching lines @@
   // Register state for stub CallFunction (from CallFunctionStub in ic-ia32.cc).
   // ----------- S t a t e -------------
   //  No registers used on entry.
   // -----------------------------------
   Generate_DebugBreakCallHelper(masm, 0, false);
 }
 
 #undef __
 
 } }  // namespace v8::internal