Rename RelocInfo::NONE to RelocInfo::NONE32.

src/arm/stub-cache-arm.cc

 // Copyright 2012 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 990 matching lines @@
     __ vstr(s0, scratch1, 0);
   } else {
     Label not_special, done;
     // 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(kBinary32SignMask == 0x80000000u);
 
     __ and_(fval, ival, Operand(kBinary32SignMask), SetCC);
     // Negate value if it is negative.
-    __ rsb(ival, ival, Operand(0, RelocInfo::NONE), LeaveCC, ne);
+    __ rsb(ival, ival, Operand(0, RelocInfo::NONE32), LeaveCC, ne);
 
     // We have -1, 0 or 1, which we treat specially. Register ival contains
     // absolute value: it is either equal to 1 (special case of -1 and 1),
     // greater than 1 (not a special case) or less than 1 (special case of 0).
     __ cmp(ival, Operand(1));
     __ b(gt, &not_special);
 
     // For 1 or -1 we need to or in the 0 exponent (biased).
     static const uint32_t exponent_word_for_1 =
         kBinary32ExponentBias << kBinary32ExponentShift;
@@ skipping 1212 matching lines @@
   // Move the result back to general purpose register r0.
   __ vmov(r0, s0);
   // Check if the result fits into a smi.
   __ add(r1, r0, Operand(0x40000000), SetCC);
   __ b(&wont_fit_smi, mi);
   // Tag the result.
   STATIC_ASSERT(kSmiTag == 0);
   __ mov(r0, Operand(r0, LSL, kSmiTagSize));
 
   // Check for -0.
-  __ cmp(r0, Operand(0, RelocInfo::NONE));
+  __ cmp(r0, Operand(0, RelocInfo::NONE32));
   __ b(&restore_fpscr_and_return, ne);
   // r5 already holds the HeapNumber exponent.
   __ tst(r5, Operand(HeapNumber::kSignMask));
   // If our HeapNumber is negative it was -0, so load its address and return.
   // Else r0 is loaded with 0, so we can also just return.
   __ ldr(r0, MemOperand(sp, 0 * kPointerSize), ne);
 
   __ bind(&restore_fpscr_and_return);
   // Restore FPSCR and return.
   __ vmsr(r3);
@@ skipping 1682 matching lines @@
         bool is_signed_type = IsElementTypeSigned(elements_kind);
         int meaningfull_bits = is_signed_type ? (kBitsPerInt - 1) : kBitsPerInt;
         int32_t min_value = is_signed_type ? 0x80000000 : 0x00000000;
 
         Label done, sign;
 
         // Test for all special exponent values: zeros, subnormal numbers, NaNs
         // and infinities. All these should be converted to 0.
         __ mov(r7, Operand(HeapNumber::kExponentMask));
         __ and_(r9, r5, Operand(r7), SetCC);
-        __ mov(r5, Operand(0, RelocInfo::NONE), LeaveCC, eq);
+        __ mov(r5, Operand(0, RelocInfo::NONE32), LeaveCC, eq);
         __ b(eq, &done);
 
         __ teq(r9, Operand(r7));
-        __ mov(r5, Operand(0, RelocInfo::NONE), LeaveCC, eq);
+        __ mov(r5, Operand(0, RelocInfo::NONE32), LeaveCC, eq);
         __ b(eq, &done);
 
         // Unbias exponent.
         __ mov(r9, Operand(r9, LSR, HeapNumber::kExponentShift));
         __ sub(r9, r9, Operand(HeapNumber::kExponentBias), SetCC);
         // If exponent is negative then result is 0.
-        __ mov(r5, Operand(0, RelocInfo::NONE), LeaveCC, mi);
+        __ mov(r5, Operand(0, RelocInfo::NONE32), LeaveCC, mi);
         __ b(mi, &done);
 
         // If exponent is too big then result is minimal value.
         __ cmp(r9, Operand(meaningfull_bits - 1));
         __ mov(r5, Operand(min_value), LeaveCC, ge);
         __ b(ge, &done);
 
         __ and_(r7, r5, Operand(HeapNumber::kSignMask), SetCC);
         __ and_(r5, r5, Operand(HeapNumber::kMantissaMask));
         __ orr(r5, r5, Operand(1u << HeapNumber::kMantissaBitsInTopWord));
 
         __ rsb(r9, r9, Operand(HeapNumber::kMantissaBitsInTopWord), SetCC);
         __ mov(r5, Operand(r5, LSR, r9), LeaveCC, pl);
         __ b(pl, &sign);
 
-        __ rsb(r9, r9, Operand(0, RelocInfo::NONE));
+        __ rsb(r9, r9, Operand(0, RelocInfo::NONE32));
         __ mov(r5, Operand(r5, LSL, r9));
         __ rsb(r9, r9, Operand(meaningfull_bits));
         __ orr(r5, r5, Operand(r6, LSR, r9));
 
         __ bind(&sign);
-        __ teq(r7, Operand(0, RelocInfo::NONE));
-        __ rsb(r5, r5, Operand(0, RelocInfo::NONE), LeaveCC, ne);
+        __ teq(r7, Operand(0, RelocInfo::NONE32));
+        __ rsb(r5, r5, Operand(0, RelocInfo::NONE32), LeaveCC, ne);
 
         __ bind(&done);
         switch (elements_kind) {
           case EXTERNAL_BYTE_ELEMENTS:
           case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
             __ strb(r5, MemOperand(r3, key, LSR, 1));
             break;
           case EXTERNAL_SHORT_ELEMENTS:
           case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
             __ strh(r5, MemOperand(r3, key, LSL, 0));
@@ skipping 380 matching lines @@
     __ Jump(ic_slow, RelocInfo::CODE_TARGET);
   }
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM