Minor cleanup of CompareIC state

src/arm/code-stubs-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 1723 matching lines @@
 
 
 static void ICCompareStub_CheckInputType(MacroAssembler* masm,
                                          Register input,
                                          Register scratch,
                                          CompareIC::State expected,
                                          Label* fail) {
   Label ok;
   if (expected == CompareIC::SMI) {
     __ JumpIfNotSmi(input, fail);
-  } else if (expected == CompareIC::HEAP_NUMBER) {
+  } else if (expected == CompareIC::NUMBER) {
     __ JumpIfSmi(input, &ok);
     __ CheckMap(input, scratch, Heap::kHeapNumberMapRootIndex, fail,
                 DONT_DO_SMI_CHECK);
   }
   // We could be strict about symbol/string here, but as long as
   // hydrogen doesn't care, the stub doesn't have to care either.
   __ bind(&ok);
 }
 
 
@@ skipping 379 matching lines @@
 
 // TODO(svenpanne): Use virtual functions instead of switch.
 void UnaryOpStub::Generate(MacroAssembler* masm) {
   switch (operand_type_) {
     case UnaryOpIC::UNINITIALIZED:
       GenerateTypeTransition(masm);
       break;
     case UnaryOpIC::SMI:
       GenerateSmiStub(masm);
       break;
-    case UnaryOpIC::HEAP_NUMBER:
-      GenerateHeapNumberStub(masm);
+    case UnaryOpIC::NUMBER:
+      GenerateNumberStub(masm);
       break;
     case UnaryOpIC::GENERIC:
       GenerateGenericStub(masm);
       break;
   }
 }
 
 
 void UnaryOpStub::GenerateTypeTransition(MacroAssembler* masm) {
   __ mov(r3, Operand(r0));  // the operand
@@ skipping 59 matching lines @@
   __ JumpIfNotSmi(r0, non_smi);
 
   // Flip bits and revert inverted smi-tag.
   __ mvn(r0, Operand(r0));
   __ bic(r0, r0, Operand(kSmiTagMask));
   __ Ret();
 }
 
 
 // TODO(svenpanne): Use virtual functions instead of switch.
-void UnaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) {
+void UnaryOpStub::GenerateNumberStub(MacroAssembler* masm) {
   switch (op_) {
     case Token::SUB:
-      GenerateHeapNumberStubSub(masm);
+      GenerateNumberStubSub(masm);
       break;
     case Token::BIT_NOT:
-      GenerateHeapNumberStubBitNot(masm);
+      GenerateNumberStubBitNot(masm);
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
-void UnaryOpStub::GenerateHeapNumberStubSub(MacroAssembler* masm) {
+void UnaryOpStub::GenerateNumberStubSub(MacroAssembler* masm) {
   Label non_smi, slow, call_builtin;
   GenerateSmiCodeSub(masm, &non_smi, &call_builtin);
   __ bind(&non_smi);
   GenerateHeapNumberCodeSub(masm, &slow);
   __ bind(&slow);
   GenerateTypeTransition(masm);
   __ bind(&call_builtin);
   GenerateGenericCodeFallback(masm);
 }
 
 
-void UnaryOpStub::GenerateHeapNumberStubBitNot(MacroAssembler* masm) {
+void UnaryOpStub::GenerateNumberStubBitNot(MacroAssembler* masm) {
   Label non_smi, slow;
   GenerateSmiCodeBitNot(masm, &non_smi);
   __ bind(&non_smi);
   GenerateHeapNumberCodeBitNot(masm, &slow);
   __ bind(&slow);
   GenerateTypeTransition(masm);
 }
 
 void UnaryOpStub::GenerateHeapNumberCodeSub(MacroAssembler* masm,
                                             Label* slow) {
@@ skipping 441 matching lines @@
       // Load the operands.
       if (smi_operands) {
         FloatingPointHelper::LoadSmis(masm, destination, scratch1, scratch2);
       } else {
         // Load right operand to d7 or r2/r3.
         if (right_type == BinaryOpIC::INT32) {
           FloatingPointHelper::LoadNumberAsInt32Double(
               masm, right, destination, d7, d8, r2, r3, heap_number_map,
               scratch1, scratch2, s0, miss);
         } else {
-          Label* fail = (right_type == BinaryOpIC::HEAP_NUMBER) ? miss
-                                                                : not_numbers;
+          Label* fail = (right_type == BinaryOpIC::NUMBER) ? miss : not_numbers;
           FloatingPointHelper::LoadNumber(
               masm, destination, right, d7, r2, r3, heap_number_map,
               scratch1, scratch2, fail);
         }
         // Load left operand to d6 or r0/r1. This keeps r0/r1 intact if it
         // jumps to |miss|.
         if (left_type == BinaryOpIC::INT32) {
           FloatingPointHelper::LoadNumberAsInt32Double(
               masm, left, destination, d6, d8, r0, r1, heap_number_map,
               scratch1, scratch2, s0, miss);
         } else {
-          Label* fail = (left_type == BinaryOpIC::HEAP_NUMBER) ? miss
-                                                               : not_numbers;
+          Label* fail = (left_type == BinaryOpIC::NUMBER) ? miss : not_numbers;
           FloatingPointHelper::LoadNumber(
               masm, destination, left, d6, r0, r1, heap_number_map,
               scratch1, scratch2, fail);
         }
       }
 
       // Calculate the result.
       if (destination == FloatingPointHelper::kVFPRegisters) {
         // Using VFP registers:
         // d6: Left value
@@ skipping 375 matching lines @@
           // Tag the result and return.
           __ SmiTag(r0, scratch1);
           __ Ret();
         } else {
           // DIV just falls through to allocating a heap number.
         }
 
         __ bind(&return_heap_number);
         // Return a heap number, or fall through to type transition or runtime
         // call if we can't.
-        if (result_type_ >= ((op_ == Token::DIV) ? BinaryOpIC::HEAP_NUMBER
+        if (result_type_ >= ((op_ == Token::DIV) ? BinaryOpIC::NUMBER
                                                  : BinaryOpIC::INT32)) {
           // We are using vfp registers so r5 is available.
           heap_number_result = r5;
           BinaryOpStub_GenerateHeapResultAllocation(masm,
                                                     heap_number_result,
                                                     heap_number_map,
                                                     scratch1,
                                                     scratch2,
                                                     &call_runtime,
                                                     mode_);
@@ skipping 203 matching lines @@
   __ bind(&check);
   __ CompareRoot(r0, Heap::kUndefinedValueRootIndex);
   __ b(ne, &done);
   if (Token::IsBitOp(op_)) {
     __ mov(r0, Operand(Smi::FromInt(0)));
   } else {
     __ LoadRoot(r0, Heap::kNanValueRootIndex);
   }
   __ bind(&done);
 
-  GenerateHeapNumberStub(masm);
+  GenerateNumberStub(masm);
 }
 
 
-void BinaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) {
+void BinaryOpStub::GenerateNumberStub(MacroAssembler* masm) {
   Label call_runtime, transition;
   BinaryOpStub_GenerateFPOperation(
       masm, left_type_, right_type_, false,
       &transition, &call_runtime, &transition, op_, mode_);
 
   __ bind(&transition);
   GenerateTypeTransition(masm);
 
   __ bind(&call_runtime);
   GenerateRegisterArgsPush(masm);
@@ skipping 3602 matching lines @@
     __ SmiUntag(r1);
     __ sub(r0, r1, SmiUntagOperand(r0));
   }
   __ Ret();
 
   __ bind(&miss);
   GenerateMiss(masm);
 }
 
 
-void ICCompareStub::GenerateHeapNumbers(MacroAssembler* masm) {
-  ASSERT(state_ == CompareIC::HEAP_NUMBER);
+void ICCompareStub::GenerateNumbers(MacroAssembler* masm) {
+  ASSERT(state_ == CompareIC::NUMBER);
 
   Label generic_stub;
   Label unordered, maybe_undefined1, maybe_undefined2;
   Label miss;
 
   if (left_ == CompareIC::SMI) {
     __ JumpIfNotSmi(r1, &miss);
   }
   if (right_ == CompareIC::SMI) {
     __ JumpIfNotSmi(r0, &miss);
@@ skipping 960 matching lines @@
 
   __ Pop(lr, r5, r1);
   __ Ret();
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM