Fix bug in propagation of type information into registers....

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 1560 matching lines @@
                                           left->reg(),
                                           ecx,
                                           left->number_info(),
                                           right->number_info(),
                                           overwrite_mode);
 
     Label do_op, left_nonsmi;
     // if right is a smi we make a fast case if left is either a smi
     // or a heapnumber.
     if (CpuFeatures::IsSupported(SSE2) && right->number_info().IsSmi()) {
+      CpuFeatures::Scope use_sse2(SSE2);
       __ mov(answer.reg(), left->reg());
       // Fast case - both are actually smis.
       if (!left->number_info().IsSmi()) {
         __ test(answer.reg(), Immediate(kSmiTagMask));
         __ j(not_zero, &left_nonsmi);
       }
       __ SmiUntag(answer.reg());
       __ jmp(&do_op);
 
       __ bind(&left_nonsmi);
@@ skipping 10 matching lines @@
       deferred->Branch(negative);
     } else {
       CheckTwoForSminess(masm_, left->reg(), right->reg(), answer.reg(),
                          left->number_info(), right->number_info(), deferred);
 
       // Untag both operands.
       __ mov(answer.reg(), left->reg());
       __ SmiUntag(answer.reg());
     }
 
+    __ bind(&do_op);
     __ SmiUntag(ecx);
     // Perform the operation.
     switch (op) {
       case Token::SAR:
         __ sar_cl(answer.reg());
         // No checks of result necessary
         break;
       case Token::SHR: {
         Label result_ok;
         __ shr_cl(answer.reg());
@@ skipping 5024 matching lines @@
         }
         case Token::ADD: {
           // Unary plus has no effect on int32 values.
           break;
         }
         default:
           UNREACHABLE();
           break;
       }
       frame_->Push(&value);
-
     } else {
       Load(node->expression());
       bool overwrite =
           (node->expression()->AsBinaryOperation() != NULL &&
            node->expression()->AsBinaryOperation()->ResultOverwriteAllowed());
       switch (op) {
         case Token::SUB: {
           GenericUnaryOpStub stub(Token::SUB, overwrite);
           Result operand = frame_->Pop();
           Result answer = frame_->CallStub(&stub, &operand);
+          answer.set_number_info(NumberInfo::Number());
           frame_->Push(&answer);
           break;
         }
-
         case Token::BIT_NOT: {
           // Smi check.
           JumpTarget smi_label;
           JumpTarget continue_label;
           Result operand = frame_->Pop();
+          NumberInfo operand_info = operand.number_info();
           operand.ToRegister();
-          __ test(operand.reg(), Immediate(kSmiTagMask));
-          smi_label.Branch(zero, &operand, taken);
+          if (operand_info.IsSmi()) {
+            if (FLAG_debug_code) {
+              __ AbortIfNotSmi(operand.reg(), "Operand not a smi.");
+            }
+            frame_->Spill(operand.reg());
+            // Set smi tag bit. It will be reset by the not operation.
+            __ lea(operand.reg(), Operand(operand.reg(), kSmiTagMask));
+            __ not_(operand.reg());
+            Result answer = operand;
+            answer.set_number_info(NumberInfo::Smi());
+            frame_->Push(&answer);
+          } else {
+            __ test(operand.reg(), Immediate(kSmiTagMask));
+            smi_label.Branch(zero, &operand, taken);
 
-          GenericUnaryOpStub stub(Token::BIT_NOT, overwrite);
-          Result answer = frame_->CallStub(&stub, &operand);
-          continue_label.Jump(&answer);
+            GenericUnaryOpStub stub(Token::BIT_NOT, overwrite);
+            Result answer = frame_->CallStub(&stub, &operand);
+            continue_label.Jump(&answer);
 
-          smi_label.Bind(&answer);
-          answer.ToRegister();
-          frame_->Spill(answer.reg());
-          __ not_(answer.reg());
-          __ and_(answer.reg(), ~kSmiTagMask);  // Remove inverted smi-tag.
+            smi_label.Bind(&answer);
+            answer.ToRegister();
+            frame_->Spill(answer.reg());
+            // Set smi tag bit. It will be reset by the not operation.
+            __ lea(answer.reg(), Operand(answer.reg(), kSmiTagMask));
+            __ not_(answer.reg());
 
-          continue_label.Bind(&answer);
-          frame_->Push(&answer);
+            continue_label.Bind(&answer);
+            if (operand_info.IsInteger32()) {
+              answer.set_number_info(NumberInfo::Integer32());
+            } else {
+              answer.set_number_info(NumberInfo::Number());
+            }
+            frame_->Push(&answer);
+          }
           break;
         }
-
         case Token::ADD: {
           // Smi check.
           JumpTarget continue_label;
           Result operand = frame_->Pop();
+          NumberInfo operand_info = operand.number_info();
           operand.ToRegister();
           __ test(operand.reg(), Immediate(kSmiTagMask));
           continue_label.Branch(zero, &operand, taken);
 
           frame_->Push(&operand);
           Result answer = frame_->InvokeBuiltin(Builtins::TO_NUMBER,
                                               CALL_FUNCTION, 1);
 
           continue_label.Bind(&answer);
+          if (operand_info.IsSmi()) {
+            answer.set_number_info(NumberInfo::Smi());
+          } else if (operand_info.IsInteger32()) {
+            answer.set_number_info(NumberInfo::Integer32());
+          } else {
+            answer.set_number_info(NumberInfo::Number());
+          }
           frame_->Push(&answer);
           break;
         }
-
         default:
           // NOT, DELETE, TYPEOF, and VOID are handled outside the
           // switch.
           UNREACHABLE();
       }
     }
   }
 }
 
 
@@ skipping 5472 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