Add inlining of binary smi operations in the full codegens on IA32...

src/full-codegen.cc

 // Copyright 2009 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 498 matching lines @@
     return;                                \
   }
   INLINE_RUNTIME_FUNCTION_LIST(CHECK_EMIT_INLINE_CALL)
 #undef CHECK_EMIT_INLINE_CALL
   UNREACHABLE();
 }
 
 
 void FullCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
   Comment cmnt(masm_, "[ BinaryOperation");
+  Token::Value op = expr->op();
+  Expression* left = expr->left();
+  Expression* right = expr->right();
 
-  OverwriteMode overwrite_mode = NO_OVERWRITE;
-  if (expr->left()->ResultOverwriteAllowed()) {
-    overwrite_mode = OVERWRITE_LEFT;
-  } else if (expr->right()->ResultOverwriteAllowed()) {
-    overwrite_mode = OVERWRITE_RIGHT;
+  OverwriteMode mode = NO_OVERWRITE;
+  if (left->ResultOverwriteAllowed()) {
+    mode = OVERWRITE_LEFT;
+  } else if (right->ResultOverwriteAllowed()) {
+    mode = OVERWRITE_RIGHT;
   }
 
-  switch (expr->op()) {
+  switch (op) {
     case Token::COMMA:
-      VisitForEffect(expr->left());
-      Visit(expr->right());
+      VisitForEffect(left);
+      Visit(right);
       break;
 
     case Token::OR:
     case Token::AND:
       EmitLogicalOperation(expr);
       break;
 
     case Token::ADD:
     case Token::SUB:
     case Token::DIV:
     case Token::MOD:
     case Token::MUL:
     case Token::BIT_OR:
     case Token::BIT_AND:
     case Token::BIT_XOR:
     case Token::SHL:
     case Token::SHR:
-    case Token::SAR:
-      VisitForValue(expr->left(), kStack);
-      VisitForValue(expr->right(), kAccumulator);
+    case Token::SAR: {
+      // Figure out if either of the operands is a constant.
+      ConstantOperand constant = ShouldInlineSmiCase(op)
+          ? GetConstantOperand(op, left, right)
+          : kNoConstants;
+
+      // Load only the operands that we need to materialize.
+      if (constant == kNoConstants) {
+        VisitForValue(left, kStack);
+        VisitForValue(right, kAccumulator);
+      } else if (constant == kRightConstant) {
+        VisitForValue(left, kAccumulator);
+      } else {
+        ASSERT(constant == kLeftConstant);
+        VisitForValue(right, kAccumulator);
+      }
+
       SetSourcePosition(expr->position());
-      EmitBinaryOp(expr->op(), context_, overwrite_mode);
+      if (ShouldInlineSmiCase(op)) {
+        EmitInlineSmiBinaryOp(expr, op, context_, mode, left, right, constant);
+      } else {
+        EmitBinaryOp(op, context_, mode);
+      }
       break;
+    }
 
     default:
       UNREACHABLE();
   }
 }
 
 
 void FullCodeGenerator::EmitLogicalOperation(BinaryOperation* expr) {
   Label eval_right, done;
 
@@ skipping 543 matching lines @@
   ASSERT(args->length() == 1);
   VisitForValue(args->at(0), kStack);
   __ CallRuntime(Runtime::kRegExpCloneResult, 1);
   Apply(context_, result_register());
 }
 
 #undef __
 
 
 } }  // namespace v8::internal