Pass the complete number type information into the GenericBinaryOpStub....

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 822 matching lines @@
   const char* op_name = Token::Name(op_);
   const char* overwrite_name;
   switch (mode_) {
     case NO_OVERWRITE: overwrite_name = "Alloc"; break;
     case OVERWRITE_RIGHT: overwrite_name = "OverwriteRight"; break;
     case OVERWRITE_LEFT: overwrite_name = "OverwriteLeft"; break;
     default: overwrite_name = "UnknownOverwrite"; break;
   }
 
   OS::SNPrintF(Vector<char>(name_, kMaxNameLength),
-               "GenericBinaryOpStub_%s_%s%s_%s%s%s",
+               "GenericBinaryOpStub_%s_%s%s_%s%s_%s",
                op_name,
                overwrite_name,
                (flags_ & NO_SMI_CODE_IN_STUB) ? "_NoSmiInStub" : "",
                args_in_registers_ ? "RegArgs" : "StackArgs",
                args_reversed_ ? "_R" : "",
-               only_numbers_in_stub_ ? "_OnlyNumbers" : "");
+               NumberInfo::ToString(operands_type_));
   return name_;
 }
 
 
 // Call the specialized stub for a binary operation.
 class DeferredInlineBinaryOperation: public DeferredCode {
  public:
   DeferredInlineBinaryOperation(Token::Value op,
                                 Register dst,
                                 Register left,
@@ skipping 143 matching lines @@
       right.is_constant() && !right.handle()->IsSmi();
 
   if (left_is_smi_constant && right_is_smi_constant) {
     // Compute the constant result at compile time, and leave it on the frame.
     int left_int = Smi::cast(*left.handle())->value();
     int right_int = Smi::cast(*right.handle())->value();
     if (FoldConstantSmis(op, left_int, right_int)) return;
   }
 
   // Get number type of left and right sub-expressions.
-  bool only_numbers = left.is_number() && right.is_number();
-  bool only_smis = left.is_smi() && right.is_smi();
+  NumberInfo::Type operands_type =
+      NumberInfo::Combine(left.number_info(), right.number_info());
 
   Result answer;
   if (left_is_non_smi_constant || right_is_non_smi_constant) {
     // Go straight to the slow case, with no smi code.
     GenericBinaryOpStub stub(op,
                              overwrite_mode,
                              NO_SMI_CODE_IN_STUB,
-                             only_numbers);
+                             operands_type);
     answer = stub.GenerateCall(masm_, frame_, &left, &right);
   } else if (right_is_smi_constant) {
     answer = ConstantSmiBinaryOperation(op, &left, right.handle(),
                                         type, false, overwrite_mode);
   } else if (left_is_smi_constant) {
     answer = ConstantSmiBinaryOperation(op, &right, left.handle(),
                                         type, true, overwrite_mode);
   } else {
     // Set the flags based on the operation, type and loop nesting level.
     // Bit operations always assume they likely operate on Smis. Still only
     // generate the inline Smi check code if this operation is part of a loop.
     // For all other operations only inline the Smi check code for likely smis
     // if the operation is part of a loop.
     if (loop_nesting() > 0 && (Token::IsBitOp(op) || type->IsLikelySmi())) {
       answer = LikelySmiBinaryOperation(op, &left, &right, overwrite_mode);
     } else {
       GenericBinaryOpStub stub(op,
                                overwrite_mode,
                                NO_GENERIC_BINARY_FLAGS,
-                               only_numbers);
+                               operands_type);
       answer = stub.GenerateCall(masm_, frame_, &left, &right);
     }
   }
 
   // Set NumberInfo of result according to the operation performed.
-  NumberInfo::Type info = NumberInfo::kUnknown;
+  // Rely on the fact that smis have a 31 bit payload on ia32.
+  ASSERT(kSmiValueSize == 31);
+  NumberInfo::Type result_type = NumberInfo::kUnknown;
   switch (op) {
     case Token::COMMA:
-      info = right.number_info();
+      result_type = right.number_info();
+      break;
     case Token::OR:
     case Token::AND:
-      // Could be anything. Check inputs.
-      if (only_numbers)
-        info = NumberInfo::kNumber;
+      // Result type can be either of the two input types.
+      result_type = operands_type;
       break;
     case Token::BIT_OR:
     case Token::BIT_XOR:
     case Token::BIT_AND:
+      // Result is always a number. Smi property of inputs is preserved.
+      result_type = (operands_type == NumberInfo::kSmi)
+          ? NumberInfo::kSmi
+          : NumberInfo::kNumber;
+      break;
     case Token::SAR:
+      // Result is a smi if we shift by a constant >= 1, otherwise a number.
+      result_type = (right.is_constant() && right.handle()->IsSmi()
+                     && Smi::cast(*right.handle())->value() >= 1)
+          ? NumberInfo::kSmi
+          : NumberInfo::kNumber;
+      break;
     case Token::SHR:
-      info = only_smis ? NumberInfo::kSmi : NumberInfo::kNumber;
+      // Result is a smi if we shift by a constant >= 2, otherwise a number.
+      result_type = (right.is_constant() && right.handle()->IsSmi()
+                     && Smi::cast(*right.handle())->value() >= 2)
+          ? NumberInfo::kSmi
+          : NumberInfo::kNumber;
+      break;
+    case Token::ADD:
+      // Result could be a string or a number. Check types of inputs.
+      result_type = NumberInfo::IsNumber(operands_type)
+          ? NumberInfo::kNumber
+          : NumberInfo::kUnknown;
       break;
     case Token::SHL:
-      info = NumberInfo::kNumber;
-      break;
-    case Token::ADD:
-      // Could be strings or numbers. Check types of inputs.
-      if (only_numbers) info = NumberInfo::kNumber;
-      break;
     case Token::SUB:
     case Token::MUL:
     case Token::DIV:
     case Token::MOD:
-      info = NumberInfo::kNumber;
+      // Result is always a number.
+      result_type = NumberInfo::kNumber;
       break;
     default:
       UNREACHABLE();
   }
-  answer.set_number_info(info);
+  answer.set_number_info(result_type);
   frame_->Push(&answer);
 }
 
 
 bool CodeGenerator::FoldConstantSmis(Token::Value op, int left, int right) {
   Object* answer_object = Heap::undefined_value();
   switch (op) {
     case Token::ADD:
       if (Smi::IsValid(left + right)) {
         answer_object = Smi::FromInt(left + right);
@@ skipping 6517 matching lines @@
   }
 
   // Floating point case.
   switch (op_) {
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV: {
       if (CpuFeatures::IsSupported(SSE2)) {
         CpuFeatures::Scope use_sse2(SSE2);
-        if (only_numbers_in_stub_) {
+        if (NumberInfo::IsNumber(operands_type_)) {
           if (FLAG_debug_code) {
             // Assert at runtime that inputs are only numbers.
             __ AbortIfNotNumber(edx,
                                 "GenericBinaryOpStub operand not a number.");
             __ AbortIfNotNumber(eax,
                                 "GenericBinaryOpStub operand not a number.");
           }
           FloatingPointHelper::LoadSSE2Operands(masm);
         } else {
           FloatingPointHelper::LoadSSE2Operands(masm, &call_runtime);
         }
 
         switch (op_) {
           case Token::ADD: __ addsd(xmm0, xmm1); break;
           case Token::SUB: __ subsd(xmm0, xmm1); break;
           case Token::MUL: __ mulsd(xmm0, xmm1); break;
           case Token::DIV: __ divsd(xmm0, xmm1); break;
           default: UNREACHABLE();
         }
         GenerateHeapResultAllocation(masm, &call_runtime);
         __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
         GenerateReturn(masm);
       } else {  // SSE2 not available, use FPU.
-        if (only_numbers_in_stub_) {
+        if (NumberInfo::IsNumber(operands_type_)) {
           if (FLAG_debug_code) {
             // Assert at runtime that inputs are only numbers.
             __ AbortIfNotNumber(edx,
                                 "GenericBinaryOpStub operand not a number.");
             __ AbortIfNotNumber(eax,
                                 "GenericBinaryOpStub operand not a number.");
           }
         } else {
           FloatingPointHelper::CheckFloatOperands(masm, &call_runtime, ebx);
         }
@@ skipping 2892 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(ExternalReference(Runtime::kStringCompare), 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal