Formatting changes and some slight improvements to revision 1621, issue 42006...

src/codegen-ia32.cc

 // Copyright 2006-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 681 matching lines @@
   // Allocate a heap number in new space with undefined value.
   // Returns tagged pointer in eax, or jumps to need_gc if new space is full.
   static void AllocateHeapNumber(MacroAssembler* masm,
                                  Label* need_gc,
                                  Register scratch1,
                                  Register scratch2);
 };
 
 
 // Flag that indicates whether or not the code that handles smi arguments
-// should be inlined, placed in the stub, or omitted entirely.
+// should be placed in the stub, inlined, or omitted entirely.
 enum GenericBinaryFlags {
   SMI_CODE_IN_STUB,
-  SMI_CODE_INLINED,
-  // It is known at compile time that at least one argument is not a smi.
-  NO_SMI_CODE
+  SMI_CODE_INLINED
 };
 
 
 class GenericBinaryOpStub: public CodeStub {
  public:
   GenericBinaryOpStub(Token::Value op,
                       OverwriteMode mode,
                       GenericBinaryFlags flags)
-      : op_(op), mode_(mode), flags_(flags) { }
+      : op_(op), mode_(mode), flags_(flags) {
+    ASSERT(OpBits::is_valid(Token::NUM_TOKENS));
+  }
 
   void GenerateSmiCode(MacroAssembler* masm, Label* slow);
 
  private:
   Token::Value op_;
   OverwriteMode mode_;
   GenericBinaryFlags flags_;
 
   const char* GetName();
 
 #ifdef DEBUG
   void Print() {
     PrintF("GenericBinaryOpStub (op %s), (mode %d, flags %d)\n",
            Token::String(op_),
            static_cast<int>(mode_),
            static_cast<int>(flags_));
   }
 #endif
 
   // Minor key encoding in 16 bits FOOOOOOOOOOOOOMM.
   class ModeBits: public BitField<OverwriteMode, 0, 2> {};
-  class OpBits: public BitField<Token::Value, 2, 12> {};
-  class FlagBits: public BitField<GenericBinaryFlags, 14, 2> {};
+  class OpBits: public BitField<Token::Value, 2, 13> {};
+  class FlagBits: public BitField<GenericBinaryFlags, 15, 1> {};
 
   Major MajorKey() { return GenericBinaryOp; }
   int MinorKey() {
     // Encode the parameters in a unique 16 bit value.
     return OpBits::encode(op_)
            | ModeBits::encode(mode_)
            | FlagBits::encode(flags_);
   }
   void Generate(MacroAssembler* masm);
 };
@@ skipping 88 matching lines @@
               : SMI_CODE_IN_STUB;
       break;
   }
 
   Result right = frame_->Pop();
   Result left = frame_->Pop();
   bool left_is_smi = left.is_constant() && left.handle()->IsSmi();
   bool left_is_non_smi = left.is_constant() && !left.handle()->IsSmi();
   bool right_is_smi = right.is_constant() && right.handle()->IsSmi();
   bool right_is_non_smi = right.is_constant() && !right.handle()->IsSmi();
+  bool generate_no_smi_code = false;  // No smi code at all, inline or in stub.
 
   if (left_is_smi && right_is_smi) {
-    // Compute the result, and return that as a constant on the frame.
+    // Compute the constant result at compile time, and leave it on the frame.
     int left_int = Smi::cast(*left.handle())->value();
     int right_int = Smi::cast(*right.handle())->value();
     if (FoldConstantSmis(op, left_int, right_int)) return;
   }
 
   if (left_is_non_smi || right_is_non_smi) {
     // Set flag so that we go straight to the slow case, with no smi code.
-    flags = NO_SMI_CODE;
+    generate_no_smi_code = true;
   } else if (right_is_smi) {
-    ConstantSmiBinaryOperation(op, &left, right.handle(), type,
-                                 false, overwrite_mode);
+    ConstantSmiBinaryOperation(op, &left, right.handle(),
+                               type, false, overwrite_mode);
     return;
   } else if (left_is_smi) {
-    ConstantSmiBinaryOperation(op, &right, left.handle(), type,
-                                 true, overwrite_mode);
+    ConstantSmiBinaryOperation(op, &right, left.handle(),
+                               type, true, overwrite_mode);
     return;
   }
 
-  if (flags == SMI_CODE_INLINED) {
+  if (flags == SMI_CODE_INLINED && !generate_no_smi_code) {
     LikelySmiBinaryOperation(op, &left, &right, overwrite_mode);
   } else {
     frame_->Push(&left);
     frame_->Push(&right);
     // If we know the arguments aren't smis, use the binary operation stub
     // that does not check for the fast smi case.
     // The same stub is used for NO_SMI_CODE and SMI_CODE_INLINED.
-    if (flags == NO_SMI_CODE) {
+    if (generate_no_smi_code) {
       flags = SMI_CODE_INLINED;
     }
     GenericBinaryOpStub stub(op, overwrite_mode, flags);
     Result answer = frame_->CallStub(&stub, 2);
     frame_->Push(&answer);
   }
 }
 
 
 bool CodeGenerator::FoldConstantSmis(Token::Value op, int left, int right) {
@@ skipping 74 matching lines @@
   }
   frame_->Push(Handle<Object>(answer_object));
   return true;
 }
 
 
 void CodeGenerator::LikelySmiBinaryOperation(Token::Value op,
                                              Result* left,
                                              Result* right,
                                              OverwriteMode overwrite_mode) {
-  // Create a new deferred code object that calls GenericBinaryOpStub
-  // in the slow case.
+  // Implements a binary operation using a deferred code object
+  // and some inline code to operate on smis quickly.
   DeferredInlineBinaryOperation* deferred =
       new DeferredInlineBinaryOperation(this, op, overwrite_mode,
                                         SMI_CODE_INLINED);
   // Generate the inline code that handles some smi operations,
   // and jumps to the deferred code for everything else.
   Result answer = deferred->GenerateInlineCode(left, right);
   deferred->BindExit(&answer);
   frame_->Push(&answer);
 }
 
@@ skipping 242 matching lines @@
       deferred->enter()->Branch(overflow, operand, not_taken);
       __ test(operand->reg(), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, operand, not_taken);
       deferred->BindExit(operand);
       frame_->Push(operand);
       break;
     }
 
     case Token::SUB: {
       DeferredCode* deferred = NULL;
-      Result answer(this);  // Only allocated a new register if reversed.
+      Result answer(this);  // Only allocate a new register if reversed.
       if (reversed) {
         answer = allocator()->Allocate();
         ASSERT(answer.is_valid());
         deferred = new DeferredInlineSmiSubReversed(this,
                                                     smi_value,
                                                     overwrite_mode);
         __ Set(answer.reg(), Immediate(value));
         if (operand->is_register()) {
           __ sub(answer.reg(), Operand(operand->reg()));
         } else {
@@ skipping 4316 matching lines @@
 
   left->ToRegister();
   right->ToRegister();
   // A newly allocated register answer is used to hold the answer.
   // The registers containing left and right are not modified in
   // most cases, so they usually don't need to be spilled in the fast case.
   Result answer = generator()->allocator()->Allocate();
 
   ASSERT(answer.is_valid());
   // Perform the smi check.
-  __ mov(answer.reg(), left->reg());
-  __ or_(answer.reg(), Operand(right->reg()));
-  ASSERT(kSmiTag == 0);  // adjust zero check if not the case
-  __ test(answer.reg(), Immediate(kSmiTagMask));
+  if (left->reg().is(right->reg())) {
+    __ test(left->reg(), Immediate(kSmiTagMask));
+  } else {
+    __ mov(answer.reg(), left->reg());
+    __ or_(answer.reg(), Operand(right->reg()));
+    ASSERT(kSmiTag == 0);  // adjust zero check if not the case
+    __ test(answer.reg(), Immediate(kSmiTagMask));
+  }
   enter()->Branch(not_zero, left, right, not_taken);
 
   // All operations start by copying the left argument into answer.
   __ mov(answer.reg(), left->reg());
   switch (op_) {
     case Token::ADD:
       __ add(answer.reg(), Operand(right->reg()));  // add optimistically
       enter()->Branch(overflow, left, right, not_taken);
       break;
 
@@ skipping 1481 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal