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

src/codegen-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 860 matching lines @@
 void Ia32CodeGenerator::LoadTypeofExpression(Expression* x) {
   Variable* variable = x->AsVariableProxy()->AsVariable();
   if (variable != NULL && !variable->is_this() && variable->is_global()) {
     // NOTE: This is somewhat nasty. We force the compiler to load
     // the variable as if through '<global>.<variable>' to make sure we
     // do not get reference errors.
     Slot global(variable, Slot::CONTEXT, Context::GLOBAL_INDEX);
     Literal key(variable->name());
     // TODO(1241834): Fetch the position from the variable instead of using
     // no position.
-    Property property(&global, &key, kNoPosition);
+    Property property(&global, &key, RelocInfo::kNoPosition);
     Load(&property);
   } else {
     Load(x, CodeGenState::LOAD_TYPEOF_EXPR);
   }
 }
 
 
 Reference::Reference(Ia32CodeGenerator* cgen, Expression* expression)
     : cgen_(cgen), expression_(expression), type_(ILLEGAL) {
   cgen->LoadReference(this);
@@ skipping 305 matching lines @@
     // Compute the name of the property.
     Literal* literal = key->AsLiteral();
     Handle<String> name(String::cast(*literal->handle()));
 
     Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
     Variable* var = ref()->expression()->AsVariableProxy()->AsVariable();
     // Setup the name register.
     __ Set(ecx, Immediate(name));
     if (var != NULL) {
       ASSERT(var->is_global());
-      __ call(ic, code_target_context);
+      __ call(ic, RelocInfo::CODE_TARGET_CONTEXT);
     } else {
-      __ call(ic, code_target);
+      __ call(ic, RelocInfo::CODE_TARGET);
     }
   } else {
     // Access keyed property.
     ASSERT(type == Reference::KEYED);
 
     // Call IC code.
     Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
     Variable* var = ref()->expression()->AsVariableProxy()->AsVariable();
     if (var != NULL) {
       ASSERT(var->is_global());
-      __ call(ic, code_target_context);
+      __ call(ic, RelocInfo::CODE_TARGET_CONTEXT);
     } else {
-      __ call(ic, code_target);
+      __ call(ic, RelocInfo::CODE_TARGET);
     }
   }
   __ push(eax);  // IC call leaves result in eax, push it out
 }
 
 
 void Ia32CodeGenerator::SetReferenceProperty(MacroAssembler* masm,
                                              Reference* ref,
                                              Expression* key) {
   ASSERT(!ref->is_illegal());
   Reference::Type type = ref->type();
 
   if (type == Reference::NAMED) {
     // Compute the name of the property.
     Literal* literal = key->AsLiteral();
     Handle<String> name(String::cast(*literal->handle()));
 
     // Call the appropriate IC code.
     Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
     // TODO(1222589): Make the IC grab the values from the stack.
     masm->pop(eax);
     // Setup the name register.
     masm->Set(ecx, Immediate(name));
-    masm->call(ic, code_target);
+    masm->call(ic, RelocInfo::CODE_TARGET);
   } else {
     // Access keyed property.
     ASSERT(type == Reference::KEYED);
 
     // Call IC code.
     Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
     // TODO(1222589): Make the IC grab the values from the stack.
     masm->pop(eax);
-    masm->call(ic, code_target);
+    masm->call(ic, RelocInfo::CODE_TARGET);
   }
   masm->push(eax);  // IC call leaves result in eax, push it out
 }
 
 
 #undef __
 #define __  masm->
 
 
 class FloatingPointHelper : public AllStatic {
@@ skipping 1355 matching lines @@
   // Fast-case: Just invoke the function.
   ParameterCount actual(argc_);
   masm->InvokeFunction(edi, actual, JUMP_FUNCTION);
 
   // Slow-case: Non-function called.
   masm->bind(&slow);
   masm->Set(eax, Immediate(argc_));
   masm->Set(ebx, Immediate(0));
   masm->GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION);
   Handle<Code> adaptor(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline));
-  masm->jmp(adaptor, code_target);
+  masm->jmp(adaptor, RelocInfo::CODE_TARGET);
 }
 
 
 // Call the function just below TOS on the stack with the given
 // arguments. The receiver is the TOS.
 void Ia32CodeGenerator::CallWithArguments(ZoneList<Expression*>* args,
                                           int position) {
   // Push the arguments ("left-to-right") on the stack.
   for (int i = 0; i < args->length(); i++) Load(args->at(i));
 
@@ skipping 309 matching lines @@
   // check range of value, if outside [0..length-1] jump to default/end label.
   ASSERT(kSmiTagSize == 1 && kSmiTag == 0);
   if (min_index != 0) {
     __ sub(Operand(eax), Immediate(min_index * 2));  // smi subtraction
   }
   __ test(eax, Immediate(0x80000000 | kSmiTagMask));  // negative or not smi
   __ j(not_equal, fail_label, not_taken);
   __ cmp(eax, range * 2);
   __ j(greater_equal, fail_label, not_taken);
 
-  __ jmp(Operand(eax, times_2, 0x0, internal_reference));  // 0 is placeholder
+  // 0 is placeholder.
+  __ jmp(Operand(eax, times_2, 0x0, RelocInfo::INTERNAL_REFERENCE));
   // calculate address to overwrite later with actual address of table.
   int32_t jump_table_ref = __ pc_offset() - sizeof(int32_t);
 
   __ Align(4);
   __ bind(&table_start);
   __ WriteInternalReference(jump_table_ref, table_start);
 
   for (int i = 0; i < range; i++) {
-    __ dd(0x0, internal_reference);  // table entry, 0 is placeholder
+    __ dd(0x0, RelocInfo::INTERNAL_REFERENCE);  // table entry, 0 is placeholder
   }
 }
 
 
 // Populate an empty jump table with the adresses of bound labels.
 void Ia32CodeGenerator::PopulateFastCaseSwitchJumpTable(
     Label &table_start, SmartPointer<Label*> &case_targets, int table_size) {
   for (int i = 0; i < table_size; i++) {
     int table_entry_pos = table_start.pos() + i * sizeof(uint32_t);
     __ WriteInternalReference(table_entry_pos, *case_targets[i]);
@@ skipping 905 matching lines @@
       case ObjectLiteral::Property::CONSTANT: break;
       case ObjectLiteral::Property::COMPUTED: {
         Handle<Object> key(property->key()->handle());
         Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
         if (key->IsSymbol()) {
           __ mov(eax, TOS);
           __ push(eax);
           Load(property->value());
           __ pop(eax);
           __ Set(ecx, Immediate(key));
-          __ call(ic, code_target);
+          __ call(ic, RelocInfo::CODE_TARGET);
           __ add(Operand(esp), Immediate(kPointerSize));
           // Ignore result.
           break;
         }
         // Fall through
       }
       case ObjectLiteral::Property::PROTOTYPE: {
         __ mov(eax, TOS);
         __ push(eax);
         Load(property->key());
@@ skipping 180 matching lines @@
     LoadGlobal();
 
     // Load the arguments.
     for (int i = 0; i < args->length(); i++) {
       Load(args->at(i));
     }
 
     // Setup the receiver register and call the IC initialization code.
     Handle<Code> stub = ComputeCallInitialize(args->length());
     __ RecordPosition(node->position());
-    __ call(stub, code_target_context);
+    __ call(stub, RelocInfo::CODE_TARGET_CONTEXT);
     __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
 
     // Overwrite the function on the stack with the result.
     __ mov(TOS, eax);
 
   } else if (var != NULL && var->slot() != NULL &&
              var->slot()->type() == Slot::LOOKUP) {
     // ----------------------------------
     // JavaScript example: 'with (obj) foo(1, 2, 3)'  // foo is in obj
     // ----------------------------------
@@ skipping 23 matching lines @@
       // Push the name of the function and the receiver onto the stack.
       __ push(Immediate(literal->handle()));
       Load(property->obj());
 
       // Load the arguments.
       for (int i = 0; i < args->length(); i++) Load(args->at(i));
 
       // Call the IC initialization code.
       Handle<Code> stub = ComputeCallInitialize(args->length());
       __ RecordPosition(node->position());
-      __ call(stub, code_target);
+      __ call(stub, RelocInfo::CODE_TARGET);
       __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
 
       // Overwrite the function on the stack with the result.
       __ mov(TOS, eax);
 
     } else {
       // -------------------------------------------
       // JavaScript example: 'array[index](1, 2, 3)'
       // -------------------------------------------
 
@@ skipping 49 matching lines @@
   __ Set(eax, Immediate(args->length()));
 
   // Load the function into temporary function slot as per calling
   // convention.
   __ mov(edi, Operand(esp, (args->length() + 1) * kPointerSize));
 
   // Call the construct call builtin that handles allocation and
   // constructor invocation.
   __ RecordPosition(node->position());
   __ call(Handle<Code>(Builtins::builtin(Builtins::JSConstructCall)),
-          js_construct_call);
+          RelocInfo::CONSTRUCT_CALL);
   __ mov(TOS, eax);  // discard the function and "push" the newly created object
 }
 
 
 void Ia32CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   Load(args->at(0));
   __ pop(eax);
   __ test(eax, Immediate(kSmiTagMask));
   cc_reg_ = zero;
@@ skipping 274 matching lines @@
     Load(args->at(i));
 
   if (function != NULL) {
     // Call the C runtime function.
     __ CallRuntime(function, args->length());
     __ push(eax);
   } else {
     // Call the JS runtime function.
     Handle<Code> stub = ComputeCallInitialize(args->length());
     __ Set(eax, Immediate(args->length()));
-    __ call(stub, code_target);
+    __ call(stub, RelocInfo::CODE_TARGET);
     __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
     __ mov(TOS, eax);
   }
 }
 
 
 void Ia32CodeGenerator::VisitUnaryOperation(UnaryOperation* node) {
   Comment cmnt(masm_, "[ UnaryOperation");
 
   Token::Value op = node->op();
@@ skipping 639 matching lines @@
 
   Load(left);
   Load(right);
   Comparison(cc, strict);
 }
 
 
 void Ia32CodeGenerator::RecordStatementPosition(Node* node) {
   if (FLAG_debug_info) {
     int pos = node->statement_pos();
-    if (pos != kNoPosition) {
+    if (pos != RelocInfo::kNoPosition) {
       __ RecordStatementPosition(pos);
     }
   }
 }
 
 
 void Ia32CodeGenerator::EnterJSFrame() {
   __ push(ebp);
   __ mov(ebp, Operand(esp));
 
@@ skipping 70 matching lines @@
                               bool do_gc,
                               bool do_restore) {
   // eax: result parameter for PerformGC, if any
   // ebx: pointer to C function  (C callee-saved)
   // ebp: frame pointer  (restored after C call)
   // esp: stack pointer  (restored after C call)
   // edi: number of arguments including receiver  (C callee-saved)
 
   if (do_gc) {
     __ mov(Operand(esp, 0 * kPointerSize), eax);  // Result.
-    __ call(FUNCTION_ADDR(Runtime::PerformGC), runtime_entry);
+    __ call(FUNCTION_ADDR(Runtime::PerformGC), RelocInfo::RUNTIME_ENTRY);
   }
 
   // Call C function.
   __ lea(eax, Operand(ebp,
                       edi,
                       times_4,
                       StandardFrameConstants::kCallerSPOffset - kPointerSize));
   __ mov(Operand(esp, 0 * kPointerSize), edi);  // argc.
   __ mov(Operand(esp, 1 * kPointerSize), eax);  // argv.
   __ call(Operand(ebx));
@@ skipping 315 matching lines @@
                                      bool is_eval) {
   Handle<Code> code = Ia32CodeGenerator::MakeCode(fun, script, is_eval);
   if (!code.is_null()) {
     Counters::total_compiled_code_size.Increment(code->instruction_size());
   }
   return code;
 }
 
 
 } }  // namespace v8::internal