Allow non-spilled frames into VisitCompareOperation, and allow them...

src/codegen-ia32.cc

 // Copyright 2006-2008 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 385 matching lines @@
 }
 
 
 void CodeGenerator::Load(Expression* x, TypeofState typeof_state) {
   JumpTarget true_target(this);
   JumpTarget false_target(this);
   LoadCondition(x, typeof_state, &true_target, &false_target, false);
 
   if (has_cc()) {
     ASSERT(frame_ != NULL);
+    frame_->SpillAll();
     // Convert cc_reg_ into a boolean value.
     JumpTarget loaded(this);
     JumpTarget materialize_true(this);
     materialize_true.Branch(cc_reg_);
     frame_->EmitPush(Immediate(Factory::false_value()));
     loaded.Jump();
     materialize_true.Bind();
     frame_->EmitPush(Immediate(Factory::true_value()));
     loaded.Bind();
     cc_reg_ = no_condition;
   }
 
   if (true_target.is_linked() || false_target.is_linked()) {
     // We have at least one condition value that has been "translated" into
     // a branch, thus it needs to be loaded explicitly.
     JumpTarget loaded(this);
     if (frame_ != NULL) {
       loaded.Jump();  // Don't lose the current TOS.
     }
     bool both = true_target.is_linked() && false_target.is_linked();
     // Load "true" if necessary.
     if (true_target.is_linked()) {
       true_target.Bind();
+      frame_->SpillAll();
       frame_->EmitPush(Immediate(Factory::true_value()));
     }
     // If both "true" and "false" need to be reincarnated jump across the
     // code for "false".
     if (both) {
       loaded.Jump();
     }
     // Load "false" if necessary.
     if (false_target.is_linked()) {
       false_target.Bind();
+      frame_->SpillAll();
       frame_->EmitPush(Immediate(Factory::false_value()));
     }
     // A value is loaded on all paths reaching this point.
     loaded.Bind();
   }
   ASSERT(frame_ != NULL);
   ASSERT(!has_cc());
 }
 
 
@@ skipping 729 matching lines @@
   done.Bind();
   cc_reg_ = cc;
 }
 
 
 class SmiComparisonDeferred: public DeferredCode {
  public:
   SmiComparisonDeferred(CodeGenerator* generator,
                         Condition cc,
                         bool strict,
-                        int value)
-      : DeferredCode(generator), cc_(cc), strict_(strict), value_(value) {
+                        Register left_side,
+                        int right_side) :
+      DeferredCode(generator),
+      cc_(cc),
+      strict_(strict),
+      left_side_(left_side),
+      right_side_(right_side) {
     set_comment("[ ComparisonDeferred");
   }
   virtual void Generate();
 
  private:
   Condition cc_;
   bool strict_;
-  int value_;
+  Register left_side_;
+  int right_side_;
 };
 
 
 void SmiComparisonDeferred::Generate() {
   CompareStub stub(cc_, strict_);
   // Setup parameters and call stub.
-  __ mov(edx, Operand(eax));
-  __ Set(eax, Immediate(Smi::FromInt(value_)));
+  if (!left_side_.is(edx)) {
+    __ mov(edx, Operand(left_side_));
+  }
+  __ Set(eax, Immediate(Smi::FromInt(right_side_)));
   __ CallStub(&stub);
   __ cmp(eax, 0);
-  // "result" is returned in the flags
+  // "result" is returned in the flags.
 }
 
 
 void CodeGenerator::SmiComparison(Condition cc,
                                   Handle<Object> value,
                                   bool strict) {
   // Strict only makes sense for equality comparisons.
   ASSERT(!strict || cc == equal);
 
   int int_value = Smi::cast(*value)->value();
   ASSERT(is_intn(int_value, kMaxSmiInlinedBits));
 
+  Result comparee = frame_->Pop();
+  comparee.ToRegister();
+  Register reg = comparee.reg();
+  __ test(reg, Immediate(kSmiTagMask));
   SmiComparisonDeferred* deferred =
-      new SmiComparisonDeferred(this, cc, strict, int_value);
-  frame_->EmitPop(eax);
-  __ test(eax, Immediate(kSmiTagMask));
+      new SmiComparisonDeferred(this, cc, strict, reg, int_value);
   deferred->enter()->Branch(not_zero, not_taken);
-  // Test smi equality by pointer comparison.
-  __ cmp(Operand(eax), Immediate(value));
+  // Test smi equality and comparison by signed int comparison.
+  __ cmp(Operand(reg), Immediate(value));
+  comparee.Unuse();
   deferred->exit()->Bind();
   cc_reg_ = cc;
 }
 
 
 class CallFunctionStub: public CodeStub {
  public:
   explicit CallFunctionStub(int argc) : argc_(argc) { }
 
   void Generate(MacroAssembler* masm);
@@ skipping 2741 matching lines @@
   // literal 'null'. If so, we optimize the code by inlining a null check
   // instead of calling the (very) general runtime routine for checking
   // equality.
   if (op == Token::EQ || op == Token::EQ_STRICT) {
     bool left_is_null =
         left->AsLiteral() != NULL && left->AsLiteral()->IsNull();
     bool right_is_null =
         right->AsLiteral() != NULL && right->AsLiteral()->IsNull();
     // The 'null' value can only be equal to 'null' or 'undefined'.
     if (left_is_null || right_is_null) {
+      frame_->SpillAll();
       Load(left_is_null ? right : left);
       frame_->SpillAll();
       frame_->EmitPop(eax);
       __ cmp(eax, Factory::null_value());
 
       // The 'null' value is only equal to 'undefined' if using non-strict
       // comparisons.
       if (op != Token::EQ_STRICT) {
         true_target()->Branch(equal);
 
@@ skipping 18 matching lines @@
   // To make typeof testing for natives implemented in JavaScript really
   // efficient, we generate special code for expressions of the form:
   // 'typeof <expression> == <string>'.
   UnaryOperation* operation = left->AsUnaryOperation();
   if ((op == Token::EQ || op == Token::EQ_STRICT) &&
       (operation != NULL && operation->op() == Token::TYPEOF) &&
       (right->AsLiteral() != NULL &&
        right->AsLiteral()->handle()->IsString())) {
     Handle<String> check(String::cast(*right->AsLiteral()->handle()));
 
+    frame_->SpillAll();
     // Load the operand and move it to register edx.
     LoadTypeofExpression(operation->expression());
     frame_->SpillAll();
     frame_->EmitPop(edx);
 
     if (check->Equals(Heap::number_symbol())) {
       __ test(edx, Immediate(kSmiTagMask));
       true_target()->Branch(zero);
       __ mov(edx, FieldOperand(edx, HeapObject::kMapOffset));
       __ cmp(edx, Factory::heap_number_map());
@@ skipping 89 matching lines @@
     case Token::GT:
       cc = greater;
       break;
     case Token::LTE:
       cc = less_equal;
       break;
     case Token::GTE:
       cc = greater_equal;
       break;
     case Token::IN: {
+      frame_->SpillAll();
       Load(left);
       frame_->SpillAll();
       Load(right);
       frame_->SpillAll();
       frame_->InvokeBuiltin(Builtins::IN, CALL_FUNCTION, 2);
       frame_->EmitPush(eax);  // push the result
       return;
     }
     case Token::INSTANCEOF: {
+      frame_->SpillAll();
       Load(left);
       frame_->SpillAll();
       Load(right);
       frame_->SpillAll();
       InstanceofStub stub;
       frame_->CallStub(&stub, 2);
       __ test(eax, Operand(eax));
       cc_reg_ = zero;
       return;
     }
     default:
       UNREACHABLE();
   }
 
   // Optimize for the case where (at least) one of the expressions
   // is a literal small integer.
   if (IsInlineSmi(left->AsLiteral())) {
+    frame_->SpillAll();
     Load(right);
     frame_->SpillAll();
     SmiComparison(ReverseCondition(cc), left->AsLiteral()->handle(), strict);
     return;
   }
   if (IsInlineSmi(right->AsLiteral())) {
     Load(left);
-    frame_->SpillAll();
     SmiComparison(cc, right->AsLiteral()->handle(), strict);
     return;
   }
 
+  frame_->SpillAll();
   Load(left);
   frame_->SpillAll();
   Load(right);
   frame_->SpillAll();
   Comparison(cc, strict);
 }
 
 
 void CodeGenerator::RecordStatementPosition(Node* node) {
   if (FLAG_debug_info) {
@@ skipping 1521 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal