Make the CompareStub and the UnaryOpStub accept smi inputs....

src/arm/codegen-arm.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 1633 matching lines @@
       __ orr(scratch, lhs, Operand(rhs));
       smi_test_reg = scratch;
     }
     __ tst(smi_test_reg, Operand(kSmiTagMask));
     JumpTarget smi;
     smi.Branch(eq);
 
     // Perform non-smi comparison by stub.
     // CompareStub takes arguments in r0 and r1, returns <0, >0 or 0 in r0.
     // We call with 0 args because there are 0 on the stack.
-    CompareStub stub(cc, strict, kBothCouldBeNaN, true, lhs, rhs);
+    CompareStub stub(cc, strict, NO_SMI_COMPARE_IN_STUB, lhs, rhs);
     frame_->CallStub(&stub, 0);
     __ cmp(r0, Operand(0, RelocInfo::NONE));
     exit.Jump();
 
     smi.Bind();
   }
 
   // Do smi comparisons by pointer comparison.
   __ cmp(lhs, Operand(rhs));
 
@@ skipping 4313 matching lines @@
       case Token::DELETE:
       case Token::TYPEOF:
         UNREACHABLE();  // handled above
         break;
 
       case Token::SUB: {
         frame_->PopToR0();
         GenericUnaryOpStub stub(
             Token::SUB,
             overwrite,
+            NO_UNARY_FLAGS,
             no_negative_zero ? kIgnoreNegativeZero : kStrictNegativeZero);
         frame_->CallStub(&stub, 0);
         frame_->EmitPush(r0);  // r0 has result
         break;
       }
 
       case Token::BIT_NOT: {
         Register tos = frame_->PopToRegister();
         JumpTarget not_smi_label;
         JumpTarget continue_label;
         // Smi check.
         __ tst(tos, Operand(kSmiTagMask));
         not_smi_label.Branch(ne);
 
         __ mvn(tos, Operand(tos));
         __ bic(tos, tos, Operand(kSmiTagMask));  // Bit-clear inverted smi-tag.
         frame_->EmitPush(tos);
         // The fast case is the first to jump to the continue label, so it gets
         // to decide the virtual frame layout.
         continue_label.Jump();
 
         not_smi_label.Bind();
         frame_->SpillAll();
         __ Move(r0, tos);
-        GenericUnaryOpStub stub(Token::BIT_NOT, overwrite);
+        GenericUnaryOpStub stub(Token::BIT_NOT,
+                                overwrite,
+                                NO_UNARY_SMI_CODE_IN_STUB);
         frame_->CallStub(&stub, 0);
         frame_->EmitPush(r0);
 
         continue_label.Bind();
         break;
       }
 
       case Token::VOID:
         frame_->Drop();
         frame_->EmitPushRoot(Heap::kUndefinedValueRootIndex);
@@ skipping 1278 matching lines @@
                BinaryOpIC::GetName(runtime_operands_type_));
   return name_;
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM