Store type information with constants. ...

src/ia32/codegen-ia32.cc

 // Copyright 2010 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 2686 matching lines @@
       right_side.Unuse();
       dest->Split(cc);
     }
   } else {
     // Neither side is a constant Smi, constant 1-char string or constant null.
     // If either side is a non-smi constant, or known to be a heap number skip
     // the smi check.
     bool known_non_smi =
         (left_side.is_constant() && !left_side.handle()->IsSmi()) ||
         (right_side.is_constant() && !right_side.handle()->IsSmi()) ||
-        left_side.number_info().IsHeapNumber() ||
-        right_side.number_info().IsHeapNumber();
+        left_side.number_info().IsDouble() ||
+        right_side.number_info().IsDouble();
     NaNInformation nan_info =
         (CouldBeNaN(left_side) && CouldBeNaN(right_side)) ?
         kBothCouldBeNaN :
         kCantBothBeNaN;
 
     // Inline number comparison handling any combination of smi's and heap
     // numbers if:
     //   code is in a loop
     //   the compare operation is different from equal
     //   compare is not a for-loop comparison
@@ skipping 110 matching lines @@
 }
 
 
 // Load a comparison operand to the FPU stack. This assumes that the operand has
 // already been checked and is a number.
 static void LoadComparisonOperand(MacroAssembler* masm_,
                                   Result* operand,
                                   Result* left_side,
                                   Result* right_side) {
   Label done;
-  if (operand->number_info().IsHeapNumber()) {
+  if (operand->number_info().IsDouble()) {
     // Operand is known to be a heap number, just load it.
     __ fld_d(FieldOperand(operand->reg(), HeapNumber::kValueOffset));
   } else if (operand->number_info().IsSmi()) {
     // Operand is known to be a smi. Convert it to double and keep the original
     // smi.
     __ SmiUntag(operand->reg());
     __ push(operand->reg());
     __ fild_s(Operand(esp, 0));
     __ pop(operand->reg());
     __ SmiTag(operand->reg());
@@ skipping 18 matching lines @@
 
 // Load a comparison operand into into a XMM register. Jump to not_numbers jump
 // target passing the left and right result if the operand is not a number.
 static void LoadComparisonOperandSSE2(MacroAssembler* masm_,
                                       Result* operand,
                                       XMMRegister reg,
                                       Result* left_side,
                                       Result* right_side,
                                       JumpTarget* not_numbers) {
   Label done;
-  if (operand->number_info().IsHeapNumber()) {
+  if (operand->number_info().IsDouble()) {
     // Operand is known to be a heap number, just load it.
     __ movdbl(reg, FieldOperand(operand->reg(), HeapNumber::kValueOffset));
   } else if (operand->number_info().IsSmi()) {
     // Operand is known to be a smi. Convert it to double and keep the original
     // smi.
     __ SmiUntag(operand->reg());
     __ cvtsi2sd(reg, Operand(operand->reg()));
     __ SmiTag(left_side->reg());
   } else {
     // Operand type not known, check for smi or heap number.
@@ skipping 7033 matching lines @@
 // Output: eax, ecx are left and right integers for a bit op.
 void FloatingPointHelper::LoadNumbersAsIntegers(MacroAssembler* masm,
                                                 NumberInfo number_info,
                                                 bool use_sse3,
                                                 Label* conversion_failure) {
   // Check float operands.
   Label arg1_is_object, check_undefined_arg1;
   Label arg2_is_object, check_undefined_arg2;
   Label load_arg2, done;
 
-  if (!number_info.IsHeapNumber()) {
+  if (!number_info.IsDouble()) {
     if (!number_info.IsSmi()) {
       __ test(edx, Immediate(kSmiTagMask));
       __ j(not_zero, &arg1_is_object);
     } else {
       if (FLAG_debug_code) __ AbortIfNotSmi(edx);
     }
     __ SmiUntag(edx);
     __ jmp(&load_arg2);
   }
 
   __ bind(&arg1_is_object);
 
   // Get the untagged integer version of the edx heap number in ecx.
   IntegerConvert(masm, edx, number_info, use_sse3, conversion_failure);
   __ mov(edx, ecx);
 
   // Here edx has the untagged integer, eax has a Smi or a heap number.
   __ bind(&load_arg2);
-  if (!number_info.IsHeapNumber()) {
+  if (!number_info.IsDouble()) {
     // Test if arg2 is a Smi.
     if (!number_info.IsSmi()) {
       __ test(eax, Immediate(kSmiTagMask));
       __ j(not_zero, &arg2_is_object);
     } else {
       if (FLAG_debug_code) __ AbortIfNotSmi(eax);
     }
     __ SmiUntag(eax);
     __ mov(ecx, eax);
     __ jmp(&done);
@@ skipping 2579 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal