Fix ambiguous method errors by explicitly passing reloc info.

src/arm/codegen-arm.cc

 // Copyright 2006-2009 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 1040 matching lines @@
   // Call the native; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   frame_->EmitPush(r0);
   Result arg_count_register = allocator_->Allocate(r0);
   ASSERT(arg_count_register.is_valid());
   __ mov(arg_count_register.reg(), Operand(arg_count));
   Result result = frame_->InvokeBuiltin(native,
                                         CALL_JS,
                                         &arg_count_register,
                                         arg_count + 1);
-  __ cmp(result.reg(), Operand(0));
+  __ cmp(result.reg(), Operand(0, RelocInfo::NONE));
   result.Unuse();
   exit.Jump();
 
   // test smi equality by pointer comparison.
   smi.Bind();
   __ cmp(r1, Operand(r0));
 
   exit.Bind();
   cc_reg_ = cc;
 }
@@ skipping 156 matching lines @@
     // Push initial value, if any.
     // Note: For variables we must not push an initial value (such as
     // 'undefined') because we may have a (legal) redeclaration and we
     // must not destroy the current value.
     if (node->mode() == Variable::CONST) {
       __ mov(r0, Operand(Factory::the_hole_value()));
       frame_->EmitPush(r0);
     } else if (node->fun() != NULL) {
       LoadAndSpill(node->fun());
     } else {
-      __ mov(r0, Operand(0));  // no initial value!
+      __ mov(r0, Operand(0, RelocInfo::NONE));  // no initial value!
       frame_->EmitPush(r0);
     }
     frame_->CallRuntime(Runtime::kDeclareContextSlot, 4);
     // Ignore the return value (declarations are statements).
     ASSERT(frame_->height() == original_height);
     return;
   }
 
   ASSERT(!var->is_global());
 
@@ skipping 621 matching lines @@
   // Check if enumerable is already a JSObject
   __ tst(r0, Operand(kSmiTagMask));
   primitive.Branch(eq);
   __ CompareObjectType(r0, r1, r1, FIRST_JS_OBJECT_TYPE);
   jsobject.Branch(hs);
 
   primitive.Bind();
   frame_->EmitPush(r0);
   Result arg_count = allocator_->Allocate(r0);
   ASSERT(arg_count.is_valid());
-  __ mov(arg_count.reg(), Operand(0));
+  __ mov(arg_count.reg(), Operand(0, RelocInfo::NONE));
   frame_->InvokeBuiltin(Builtins::TO_OBJECT, CALL_JS, &arg_count, 1);
 
   jsobject.Bind();
   // Get the set of properties (as a FixedArray or Map).
   frame_->EmitPush(r0);  // duplicate the object being enumerated
   frame_->EmitPush(r0);
   frame_->CallRuntime(Runtime::kGetPropertyNamesFast, 1);
 
   // If we got a Map, we can do a fast modification check.
   // Otherwise, we got a FixedArray, and we have to do a slow check.
@@ skipping 1673 matching lines @@
       case Token::BIT_NOT: {
         // smi check
         JumpTarget smi_label;
         JumpTarget continue_label;
         __ tst(r0, Operand(kSmiTagMask));
         smi_label.Branch(eq);
 
         frame_->EmitPush(r0);
         Result arg_count = allocator_->Allocate(r0);
         ASSERT(arg_count.is_valid());
-        __ mov(arg_count.reg(), Operand(0));  // not counting receiver
+        // not counting receiver

[William Hesse, 2009/06/15 08:59:29]

// Argument count does not include the receiver.
Comments should be grammatical sentences.  Since you are
moving the comment anyway, let's fix it.

+        __ mov(arg_count.reg(), Operand(0, RelocInfo::NONE));
         frame_->InvokeBuiltin(Builtins::BIT_NOT, CALL_JS, &arg_count, 1);
 
         continue_label.Jump();
         smi_label.Bind();
         __ mvn(r0, Operand(r0));
         __ bic(r0, r0, Operand(kSmiTagMask));  // bit-clear inverted smi-tag
         continue_label.Bind();
         break;
       }
 
       case Token::VOID:
         // since the stack top is cached in r0, popping and then
         // pushing a value can be done by just writing to r0.
         __ mov(r0, Operand(Factory::undefined_value()));
         break;
 
       case Token::ADD: {
         // Smi check.
         JumpTarget continue_label;
         __ tst(r0, Operand(kSmiTagMask));
         continue_label.Branch(eq);
         frame_->EmitPush(r0);
         Result arg_count = allocator_->Allocate(r0);
         ASSERT(arg_count.is_valid());
-        __ mov(arg_count.reg(), Operand(0));  // not counting receiver
+        // not counting receiver
+        __ mov(arg_count.reg(), Operand(0, RelocInfo::NONE));
         frame_->InvokeBuiltin(Builtins::TO_NUMBER, CALL_JS, &arg_count, 1);
         continue_label.Bind();
         break;
       }
       default:
         UNREACHABLE();
     }
     frame_->EmitPush(r0);  // r0 has result
   }
   ASSERT((has_cc() && frame_->height() == original_height) ||
          (!has_cc() && frame_->height() == original_height + 1));
 }
 
 
 void CodeGenerator::VisitCountOperation(CountOperation* node) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ CountOperation");
 
   bool is_postfix = node->is_postfix();
   bool is_increment = node->op() == Token::INC;
 
   Variable* var = node->expression()->AsVariableProxy()->AsVariable();
   bool is_const = (var != NULL && var->mode() == Variable::CONST);
 
   // Postfix: Make room for the result.
   if (is_postfix) {
-     __ mov(r0, Operand(0));
+     __ mov(r0, Operand(0, RelocInfo::NONE));
      frame_->EmitPush(r0);
   }
 
   { Reference target(this, node->expression());
     if (target.is_illegal()) {
       // Spoof the virtual frame to have the expected height (one higher
       // than on entry).
       if (!is_postfix) {
         __ mov(r0, Operand(Smi::FromInt(0)));
         frame_->EmitPush(r0);
@@ skipping 36 matching lines @@
       __ add(r0, r0, Operand(r1));
     }
 
     // Slow case: Convert to number.
     slow.Bind();
     {
       // Convert the operand to a number.
       frame_->EmitPush(r0);
       Result arg_count = allocator_->Allocate(r0);
       ASSERT(arg_count.is_valid());
-      __ mov(arg_count.reg(), Operand(0));
+      __ mov(arg_count.reg(), Operand(0, RelocInfo::NONE));
       frame_->InvokeBuiltin(Builtins::TO_NUMBER, CALL_JS, &arg_count, 1);
     }
     if (is_postfix) {
       // Postfix: store to result (on the stack).
       __ str(r0, frame_->ElementAt(target.size()));
     }
 
     // Compute the new value.
     __ mov(r1, Operand(Smi::FromInt(1)));
     frame_->EmitPush(r0);
@@ skipping 627 matching lines @@
 // instruction.  On pre-ARM5 hardware this routine gives the wrong answer for 0
 // (31 instead of 32).
 static void CountLeadingZeros(
     MacroAssembler* masm,
     Register source,
     Register scratch,
     Register zeros) {
 #ifdef __ARM_ARCH_5__
   __ clz(zeros, source);  // This instruction is only supported after ARM5.
 #else
-  __ mov(zeros, Operand(0));
+  __ mov(zeros, Operand(0, RelocInfo::NONE));
   __ mov(scratch, source);
   // Top 16.
   __ tst(scratch, Operand(0xffff0000));
   __ add(zeros, zeros, Operand(16), LeaveCC, eq);
   __ mov(scratch, Operand(scratch, LSL, 16), LeaveCC, eq);
   // Top 8.
   __ tst(scratch, Operand(0xff000000));
   __ add(zeros, zeros, Operand(8), LeaveCC, eq);
   __ mov(scratch, Operand(scratch, LSL, 8), LeaveCC, eq);
   // Top 4.
@@ skipping 66 matching lines @@
 #endif
   Label not_special;
   // Convert from Smi to integer.
   __ mov(source_, Operand(source_, ASR, kSmiTagSize));
   // Move sign bit from source to destination.  This works because the sign bit
   // in the exponent word of the double has the same position and polarity as
   // the 2's complement sign bit in a Smi.
   ASSERT(HeapNumber::kSignMask == 0x80000000u);
   __ and_(exponent, source_, Operand(HeapNumber::kSignMask), SetCC);
   // Subtract from 0 if source was negative.
-  __ rsb(source_, source_, Operand(0), LeaveCC, ne);
+  __ rsb(source_, source_, Operand(0, RelocInfo::NONE), LeaveCC, ne);
   __ cmp(source_, Operand(1));
   __ b(gt, &not_special);
 
   // We have -1, 0 or 1, which we treat specially.
-  __ cmp(source_, Operand(0));
+  __ cmp(source_, Operand(0, RelocInfo::NONE));
   // For 1 or -1 we need to or in the 0 exponent (biased to 1023).
   static const uint32_t exponent_word_for_1 =
       HeapNumber::kExponentBias << HeapNumber::kExponentShift;
   __ orr(exponent, exponent, Operand(exponent_word_for_1), LeaveCC, ne);
   // 1, 0 and -1 all have 0 for the second word.
-  __ mov(mantissa, Operand(0));
+  __ mov(mantissa, Operand(0, RelocInfo::NONE));
   __ Ret();
 
   __ bind(&not_special);
   // Count leading zeros.  Uses result2 for a scratch register on pre-ARM5.
   // Gets the wrong answer for 0, but we already checked for that case above.
   CountLeadingZeros(masm, source_, mantissa, zeros_);
   // Compute exponent and or it into the exponent register.
   // We use result2 as a scratch register here.
   __ rsb(mantissa, zeros_, Operand(31 + HeapNumber::kExponentBias));
   __ orr(exponent,
@@ skipping 62 matching lines @@
   __ cmp(the_int_, Operand(0x80000000));
   __ b(eq, &max_negative_int);
   // Set up the correct exponent in scratch_.  All non-Smi int32s have the same.
   // A non-Smi integer is 1.xxx * 2^30 so the exponent is 30 (biased).
   uint32_t non_smi_exponent =
       (HeapNumber::kExponentBias + 30) << HeapNumber::kExponentShift;
   __ mov(scratch_, Operand(non_smi_exponent));
   // Set the sign bit in scratch_ if the value was negative.
   __ orr(scratch_, scratch_, Operand(HeapNumber::kSignMask), LeaveCC, cs);
   // Subtract from 0 if the value was negative.
-  __ rsb(the_int_, the_int_, Operand(0), LeaveCC, cs);
+  __ rsb(the_int_, the_int_, Operand(0, RelocInfo::NONE), LeaveCC, cs);
   // We should be masking the implict first digit of the mantissa away here,
   // but it just ends up combining harmlessly with the last digit of the
   // exponent that happens to be 1.  The sign bit is 0 so we shift 10 to get
   // the most significant 1 to hit the last bit of the 12 bit sign and exponent.
   ASSERT(((1 << HeapNumber::kExponentShift) & non_smi_exponent) != 0);
   const int shift_distance = HeapNumber::kNonMantissaBitsInTopWord - 2;
   __ orr(scratch_, scratch_, Operand(the_int_, LSR, shift_distance));
   __ str(scratch_, FieldMemOperand(the_heap_number_,
                                    HeapNumber::kExponentOffset));
   __ mov(scratch_, Operand(the_int_, LSL, 32 - shift_distance));
   __ str(scratch_, FieldMemOperand(the_heap_number_,
                                    HeapNumber::kMantissaOffset));
   __ Ret();
 
   __ bind(&max_negative_int);
   // The max negative int32 is stored as a positive number in the mantissa of
   // a double because it uses a sign bit instead of using two's complement.
   // The actual mantissa bits stored are all 0 because the implicit most
   // significant 1 bit is not stored.
   non_smi_exponent += 1 << HeapNumber::kExponentShift;
   __ mov(ip, Operand(HeapNumber::kSignMask | non_smi_exponent));
   __ str(ip, FieldMemOperand(the_heap_number_, HeapNumber::kExponentOffset));
-  __ mov(ip, Operand(0));
+  __ mov(ip, Operand(0, RelocInfo::NONE));
   __ str(ip, FieldMemOperand(the_heap_number_, HeapNumber::kMantissaOffset));
   __ Ret();
 }
 
 
 // Allocates a heap number or jumps to the label if the young space is full and
 // a scavenge is needed.
 static void AllocateHeapNumber(
     MacroAssembler* masm,
     Label* need_gc,       // Jump here if young space is full.
@@ skipping 185 matching lines @@
   // leave the sign bit 0 so we subtract 2 bits from the shift distance.
   const int shift_distance = HeapNumber::kNonMantissaBitsInTopWord - 2;
   __ mov(scratch2, Operand(scratch2, LSL, shift_distance));
   // Put sign in zero flag.
   __ tst(scratch, Operand(HeapNumber::kSignMask));
   // Get the second half of the double.
   __ ldr(scratch, FieldMemOperand(source, HeapNumber::kMantissaOffset));
   // Shift down 22 bits to get the last 10 bits.
   __ orr(dest, scratch2, Operand(scratch, LSR, 32 - shift_distance));
   // Fix sign if sign bit was set.
-  __ rsb(dest, dest, Operand(0), LeaveCC, ne);
+  __ rsb(dest, dest, Operand(0, RelocInfo::NONE), LeaveCC, ne);
 }
 
 
 // For bitwise ops where the inputs are not both Smis we here try to determine
 // whether both inputs are either Smis or at least heap numbers that can be
 // represented by a 32 bit signed value.  We truncate towards zero as required
 // by the ES spec.  If this is the case we do the bitwise op and see if the
 // result is a Smi.  If so, great, otherwise we try to find a heap number to
 // write the answer into (either by allocating or by overwriting).
 // On entry the operands are in r0 and r1.  On exit the answer is in r0.
@@ skipping 290 matching lines @@
   Label slow;
   Label done;
   Label not_smi;
 
   // Enter runtime system if the value is not a smi.
   __ tst(r0, Operand(kSmiTagMask));
   __ b(ne, &not_smi);
 
   // Enter runtime system if the value of the expression is zero
   // to make sure that we switch between 0 and -0.
-  __ cmp(r0, Operand(0));
+  __ cmp(r0, Operand(0, RelocInfo::NONE));
   __ b(eq, &slow);
 
   // The value of the expression is a smi that is not zero.  Try
   // optimistic subtraction '0 - value'.
-  __ rsb(r1, r0, Operand(0), SetCC);
+  __ rsb(r1, r0, Operand(0, RelocInfo::NONE), SetCC);
   __ b(vs, &slow);
 
   __ mov(r0, Operand(r1));  // Set r0 to result.
   __ StubReturn(1);
 
   // Enter runtime system.
   __ bind(&slow);
   __ push(r0);
-  __ mov(r0, Operand(0));  // Set number of arguments.
+  __ mov(r0, Operand(0, RelocInfo::NONE));  // Set number of arguments.
   __ InvokeBuiltin(Builtins::UNARY_MINUS, JUMP_JS);
 
   __ bind(&done);
   __ StubReturn(1);
 
   __ bind(&not_smi);
   __ CompareObjectType(r0, r1, r1, HEAP_NUMBER_TYPE);
   __ b(ne, &slow);
   // r0 is a heap number.  Get a new heap number in r1.
   if (overwrite_) {
@@ skipping 26 matching lines @@
   // Restore the next handler and frame pointer, discard handler state.
   ASSERT(StackHandlerConstants::kNextOffset == 0);
   __ pop(r2);
   __ str(r2, MemOperand(r3));
   ASSERT(StackHandlerConstants::kFPOffset == 2 * kPointerSize);
   __ ldm(ia_w, sp, r3.bit() | fp.bit());  // r3: discarded state.
 
   // Before returning we restore the context from the frame pointer if
   // not NULL.  The frame pointer is NULL in the exception handler of a
   // JS entry frame.
-  __ cmp(fp, Operand(0));
+  __ cmp(fp, Operand(0, RelocInfo::NONE));
   // Set cp to NULL if fp is NULL.
-  __ mov(cp, Operand(0), LeaveCC, eq);
+  __ mov(cp, Operand(0, RelocInfo::NONE), LeaveCC, eq);
   // Restore cp otherwise.
   __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset), ne);
 #ifdef DEBUG
   if (FLAG_debug_code) {
     __ mov(lr, Operand(pc));
   }
 #endif
   ASSERT(StackHandlerConstants::kPCOffset == 3 * kPointerSize);
   __ pop(pc);
 }
@@ skipping 21 matching lines @@
   __ jmp(&loop);
   __ bind(&done);
 
   // Set the top handler address to next handler past the current ENTRY handler.
   ASSERT(StackHandlerConstants::kNextOffset == 0);
   __ pop(r0);
   __ str(r0, MemOperand(r3));
 
   // Set external caught exception to false.
   ExternalReference external_caught(Top::k_external_caught_exception_address);
-  __ mov(r0, Operand(false));
+  __ mov(r0, Operand(0, RelocInfo::NONE));
   __ mov(r2, Operand(external_caught));
   __ str(r0, MemOperand(r2));
 
   // Set pending exception and r0 to out of memory exception.
   Failure* out_of_memory = Failure::OutOfMemoryException();
   __ mov(r0, Operand(reinterpret_cast<int32_t>(out_of_memory)));
   __ mov(r2, Operand(ExternalReference(Top::k_pending_exception_address)));
   __ str(r0, MemOperand(r2));
 
   // Stack layout at this point. See also StackHandlerConstants.
   // sp ->   state (ENTRY)
   //         fp
   //         lr
 
   // Discard handler state (r2 is not used) and restore frame pointer.
   ASSERT(StackHandlerConstants::kFPOffset == 2 * kPointerSize);
   __ ldm(ia_w, sp, r2.bit() | fp.bit());  // r2: discarded state.
   // Before returning we restore the context from the frame pointer if
   // not NULL.  The frame pointer is NULL in the exception handler of a
   // JS entry frame.
-  __ cmp(fp, Operand(0));
+  __ cmp(fp, Operand(0, RelocInfo::NONE));
   // Set cp to NULL if fp is NULL.
-  __ mov(cp, Operand(0), LeaveCC, eq);
+  __ mov(cp, Operand(0, RelocInfo::NONE), LeaveCC, eq);
   // Restore cp otherwise.
   __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset), ne);
 #ifdef DEBUG
   if (FLAG_debug_code) {
     __ mov(lr, Operand(pc));
   }
 #endif
   ASSERT(StackHandlerConstants::kPCOffset == 3 * kPointerSize);
   __ pop(pc);
 }
@@ skipping 449 matching lines @@
   __ b(ne, &slow);
 
   // Fast-case: Invoke the function now.
   // r1: pushed function
   ParameterCount actual(argc_);
   __ InvokeFunction(r1, actual, JUMP_FUNCTION);
 
   // Slow-case: Non-function called.
   __ bind(&slow);
   __ mov(r0, Operand(argc_));  // Setup the number of arguments.
-  __ mov(r2, Operand(0));
+  __ mov(r2, Operand(0, RelocInfo::NONE));
   __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION);
   __ Jump(Handle<Code>(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline)),
           RelocInfo::CODE_TARGET);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal