Move implementation of comparisons with constant smis to use...

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 1311 matching lines @@
         ASSERT(right_side.is_valid());
         __ cmp(left_side.reg(), Operand(right_side.reg()));
       } else {
       __ cmp(Operand(left_side.reg()), Immediate(right_side.handle()));
       }
       left_side.Unuse();
       right_side.Unuse();
       dest->Split(cc);
     }
   } else {  // Neither side is a constant Smi, normal comparison operation.
+    // If either side is a non-smi constant, 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.ToRegister();
     right_side.ToRegister();
-    ASSERT(left_side.is_valid());
-    ASSERT(right_side.is_valid());
-    // Check for the smi case.
     JumpTarget is_smi(this);
-    Result temp = allocator_->Allocate();
-    ASSERT(temp.is_valid());
-    __ mov(temp.reg(), left_side.reg());
-    __ or_(temp.reg(), Operand(right_side.reg()));
-    __ test(temp.reg(), Immediate(kSmiTagMask));
-    temp.Unuse();
-    is_smi.Branch(zero, &left_side, &right_side, taken);
-
+    if (!known_non_smi) {
+      // Check for the smi case.
+      Result temp = allocator_->Allocate();
+      ASSERT(temp.is_valid());
+      __ mov(temp.reg(), left_side.reg());
+      __ or_(temp.reg(), Operand(right_side.reg()));
+      __ test(temp.reg(), Immediate(kSmiTagMask));
+      temp.Unuse();
+      is_smi.Branch(zero, &left_side, &right_side, taken);
+    }
     // When non-smi, call out to the compare stub.  "parameters" setup by
     // calling code in edx and eax and "result" is returned in the flags.
     if (!left_side.reg().is(eax)) {
       right_side.ToRegister(eax);
       left_side.ToRegister(edx);
     } else if (!right_side.reg().is(edx)) {
       left_side.ToRegister(edx);
       right_side.ToRegister(eax);
     } else {
       frame_->Spill(eax);  // Can be multiply referenced, even now.
       frame_->Spill(edx);
       __ xchg(eax, edx);
       // If left_side and right_side become real (non-dummy) arguments
       // to CallStub, they need to be swapped in this case.
     }
     CompareStub stub(cc, strict);
     Result answer = frame_->CallStub(&stub, &right_side, &left_side, 0);
     if (cc == equal) {
       __ test(answer.reg(), Operand(answer.reg()));
     } else {
       __ cmp(answer.reg(), 0);
     }
     answer.Unuse();
-    dest->true_target()->Branch(cc);
-    dest->false_target()->Jump();
-
-    is_smi.Bind(&left_side, &right_side);
-    left_side.ToRegister();
-    right_side.ToRegister();
-    __ cmp(left_side.reg(), Operand(right_side.reg()));
-    right_side.Unuse();
-    left_side.Unuse();
-    dest->Split(cc);
+    if (known_non_smi) {
+      dest->Split(cc);
+    } else {
+      dest->true_target()->Branch(cc);
+      dest->false_target()->Jump();
+      is_smi.Bind(&left_side, &right_side);
+      left_side.ToRegister();
+      right_side.ToRegister();
+      __ cmp(left_side.reg(), Operand(right_side.reg()));
+      right_side.Unuse();
+      left_side.Unuse();
+      dest->Split(cc);
+    }
   }
 }
 
 
-void CodeGenerator::SmiComparison(Condition cc,
-                                  Handle<Object> smi_value,
-                                  bool strict) {
-  // Strict only makes sense for equality comparisons.
-  ASSERT(!strict || cc == equal);
-  ASSERT(is_intn(Smi::cast(*smi_value)->value(), kMaxSmiInlinedBits));
-
-  JumpTarget is_smi(this);
-  Result comparee = frame_->Pop();
-  comparee.ToRegister();
-  // Check whether the other operand is a smi.
-  __ test(comparee.reg(), Immediate(kSmiTagMask));
-  is_smi.Branch(zero, &comparee, taken);
-
-  // Setup and call the compare stub, which expects arguments in edx
-  // and eax.
-  CompareStub stub(cc, strict);
-  comparee.ToRegister(edx);
-  Result value = allocator_->Allocate(eax);
-  ASSERT(value.is_valid());
-  __ Set(value.reg(), Immediate(smi_value));
-  Result result = frame_->CallStub(&stub, &comparee, &value, 0);
-  __ cmp(result.reg(), 0);
-  result.Unuse();
-  destination()->true_target()->Branch(cc);
-  destination()->false_target()->Jump();
-
-  is_smi.Bind(&comparee);
-  comparee.ToRegister();
-  // Test smi equality and comparison by signed int comparison.
-  __ cmp(Operand(comparee.reg()), Immediate(smi_value));
-  comparee.Unuse();
-  destination()->Split(cc);
-}
-
-
 class CallFunctionStub: public CodeStub {
  public:
   explicit CallFunctionStub(int argc) : argc_(argc) { }
 
   void Generate(MacroAssembler* masm);
 
  private:
   int argc_;
 
 #ifdef DEBUG
@@ skipping 3306 matching lines @@
       Result answer = frame_->CallStub(&stub, 2);
       answer.ToRegister();
       __ test(answer.reg(), Operand(answer.reg()));
       answer.Unuse();
       destination()->Split(zero);
       return;
     }
     default:
       UNREACHABLE();
   }
-
-  // Optimize for the case where (at least) one of the expressions
-  // is a literal small integer.
-  if (IsInlineSmi(left->AsLiteral())) {
-    Load(right);
-    SmiComparison(ReverseCondition(cc), left->AsLiteral()->handle(), strict);
-  } else if (IsInlineSmi(right->AsLiteral())) {
-    Load(left);
-    SmiComparison(cc, right->AsLiteral()->handle(), strict);
-  } else {
-    Load(left);
-    Load(right);
-    Comparison(cc, strict, destination());
-  }
+  Load(left);
+  Load(right);
+  Comparison(cc, strict, destination());
 }
 
 
 #ifdef DEBUG
 bool CodeGenerator::HasValidEntryRegisters() {
   return (allocator()->count(eax) == frame()->register_count(eax))
       && (allocator()->count(ebx) == frame()->register_count(ebx))
       && (allocator()->count(ecx) == frame()->register_count(ecx))
       && (allocator()->count(edx) == frame()->register_count(edx))
       && (allocator()->count(edi) == frame()->register_count(edi));
@@ skipping 1798 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal