Fix build.

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().IsDouble() ||
-        right_side.number_info().IsDouble();
+        left_side.type_info().IsDouble() ||
+        right_side.type_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 91 matching lines @@
 
 
 // Check that the comparison operand is a number. Jump to not_numbers jump
 // target passing the left and right result if the operand is not a number.
 static void CheckComparisonOperand(MacroAssembler* masm_,
                                    Result* operand,
                                    Result* left_side,
                                    Result* right_side,
                                    JumpTarget* not_numbers) {
   // Perform check if operand is not known to be a number.
-  if (!operand->number_info().IsNumber()) {
+  if (!operand->type_info().IsNumber()) {
     Label done;
     __ test(operand->reg(), Immediate(kSmiTagMask));
     __ j(zero, &done);
     __ cmp(FieldOperand(operand->reg(), HeapObject::kMapOffset),
            Immediate(Factory::heap_number_map()));
     not_numbers->Branch(not_equal, left_side, right_side, not_taken);
     __ bind(&done);
   }
 }
 
 
 // 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) {
   Label done;
-  if (operand->number_info().IsDouble()) {
+  if (operand->type_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()) {
+  } else if (operand->type_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());
   } else {
     // Operand type not known, check for smi otherwise assume heap number.
     Label smi;
@@ skipping 15 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().IsDouble()) {
+  if (operand->type_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()) {
+  } else if (operand->type_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(operand->reg());
   } else {
     // Operand type not known, check for smi or heap number.
     Label smi;
     __ test(operand->reg(), Immediate(kSmiTagMask));
     __ j(zero, &smi);
-    if (!operand->number_info().IsNumber()) {
+    if (!operand->type_info().IsNumber()) {
       __ cmp(FieldOperand(operand->reg(), HeapObject::kMapOffset),
              Immediate(Factory::heap_number_map()));
       not_numbers->Branch(not_equal, left_side, right_side, taken);
     }
     __ movdbl(reg, FieldOperand(operand->reg(), HeapNumber::kValueOffset));
     __ jmp(&done);
 
     __ bind(&smi);
     // Comvert smi to float and keep the original smi.
     __ SmiUntag(operand->reg());
@@ skipping 9638 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