Code generation for multiply-by-constant-smi....

src/ia32/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 1598 matching lines @@
     case Token::SHR:
       if (reversed) {
         Result constant_operand(value);
         LikelySmiBinaryOperation(op, &constant_operand, operand,
                                  overwrite_mode);
       } else {
         // Only the least significant 5 bits of the shift value are used.
         // In the slow case, this masking is done inside the runtime call.
         int shift_value = int_value & 0x1f;
         operand->ToRegister();
-        Result answer = allocator()->Allocate();
-        ASSERT(answer.is_valid());
+        frame_->Spill(operand->reg());
         DeferredInlineSmiOperation* deferred =
             new DeferredInlineSmiOperation(op,
-                                           answer.reg(),
+                                           operand->reg(),
                                            operand->reg(),
                                            smi_value,
                                            overwrite_mode);
-        __ test(operand->reg(), Immediate(kSmiTagMask));
-        deferred->Branch(not_zero);
-        __ mov(answer.reg(), operand->reg());
-        __ sar(answer.reg(), kSmiTagSize);
-        __ shr(answer.reg(), shift_value);
-        // A negative Smi shifted right two is in the positive Smi range.
         if (shift_value < 2) {
-          __ test(answer.reg(), Immediate(0xc0000000));
+          // A negative Smi shifted by 0 or 1 is too big to fit in the positive
+          // Smi range.  Fold the test into the Smi tag test.
+          __ test(operand->reg(), Immediate(kSmiTagMask | 0x80000000));
           deferred->Branch(not_zero);
+          if (shift_value == 1) {
+            __ shr(operand->reg(), 1);
+            __ and_(operand->reg(), ~kSmiTagMask);
+          }
+        } else {
+          __ test(operand->reg(), Immediate(kSmiTagMask));
+          deferred->Branch(not_zero);
+          __ sar(operand->reg(), 1);
+          __ shr(operand->reg(), shift_value - 1);
+          __ and_(operand->reg(), ~kSmiTagMask);
         }
-        operand->Unuse();
-        ASSERT(kSmiTagSize == times_2);  // Adjust the code if not true.
-        __ lea(answer.reg(),
-               Operand(answer.reg(), answer.reg(), times_1, kSmiTag));
+        ASSERT(kSmiTag == 0);  // adjust code if not the case
+        ASSERT(kSmiTagSize == 1);  // Adjust the code if not true.
         deferred->BindExit();
-        frame_->Push(&answer);
+        frame_->Push(operand);
       }
       break;
 
     case Token::SHL:
       if (reversed) {
         Result constant_operand(value);
         LikelySmiBinaryOperation(op, &constant_operand, operand,
                                  overwrite_mode);
       } else {
         // Only the least significant 5 bits of the shift value are used.
@@ skipping 73 matching lines @@
         ASSERT(op == Token::BIT_OR);
         if (int_value != 0) {
           __ or_(Operand(operand->reg()), Immediate(value));
         }
       }
       deferred->BindExit();
       frame_->Push(operand);
       break;
     }
 
+    case Token::MUL: {
+      operand->ToRegister();
+      frame_->Spill(operand->reg());
+      DeferredCode* deferred = NULL;
+      Result* answer = NULL;
+      Result answer_reg;
+      if (int_value == 0 || int_value == 1 || int_value == -1) {
+        // Re-use operand register.
+        answer = operand;
+      } else {
+        // Need a fresh register.
+        answer_reg = allocator()->Allocate();
+        answer = &answer_reg;
+        ASSERT(answer->is_valid());
+      }
+      if (reversed) {
+        deferred = new DeferredInlineSmiOperationReversed(op,
+                                                          answer->reg(),
+                                                          smi_value,
+                                                          operand->reg(),
+                                                          overwrite_mode);
+      } else {
+        deferred =  new DeferredInlineSmiOperation(op,
+                                                   answer->reg(),
+                                                   operand->reg(),
+                                                   smi_value,
+                                                   overwrite_mode);
+      }
+      __ test(operand->reg(), Immediate(kSmiTagMask));
+      deferred->Branch(not_zero);
+      ASSERT(kSmiTag == 0 && kSmiTagSize == 1);
+
+      if (int_value == 1) {
+        // Already have correct value in 'answer'.
+        ASSERT(answer == operand);
+      } else if (int_value == 0) {
+        // The result is positive zero or negative zero depending on the sign of
+        // the operand.
+        __ test(operand->reg(), Operand(operand->reg()));
+        deferred->Branch(negative);
+        __ Set(answer->reg(), Immediate(0));
+      } else if (int_value == -1) {
+        ASSERT(answer == operand);
+        __ neg(answer->reg());
+        // The only value that can overflow is MIN_SMI, for which negation
+        // yields the same bit pattern.  Thus the operand register, although
+        // negated, holds the original value, ready for the deferred code.
+        deferred->Branch(overflow);
+        // If the result is zero, it should be negative zero.  Again, the
+        // operand register, although negated, contains the original value!
+        deferred->Branch(zero);
+      } else {
+        __ imul(answer->reg(), operand->reg(), int_value);
+        deferred->Branch(overflow);
+
+        if (int_value < 0) {  // Negative zero test.
+          __ test(answer->reg(), Operand(answer->reg()));
+          deferred->Branch(zero);
+        }
+      }
+      deferred->BindExit();
+      if (operand != answer) {
+        operand->Unuse();
+      }
+      frame_->Push(answer);
+      break;
+    }
+
     // Generate inline code for mod of powers of 2 and negative powers of 2.
     case Token::MOD:
       if (!reversed &&
           int_value != 0 &&
           (IsPowerOf2(int_value) || IsPowerOf2(-int_value))) {
         operand->ToRegister();
         frame_->Spill(operand->reg());
         DeferredCode* deferred = new DeferredInlineSmiOperation(op,
                                                                 operand->reg(),
                                                                 operand->reg(),
@@ skipping 5542 matching lines @@
   __ j(not_equal, non_float);  // argument in eax is not a number -> NaN
 
   // Fall-through: Both operands are numbers.
   __ bind(&done);
 }
 
 
 void UnarySubStub::Generate(MacroAssembler* masm) {
   Label undo;
   Label slow;
-  Label done;
   Label try_float;
 
   // Check whether the value is a smi.
   __ test(eax, Immediate(kSmiTagMask));
   __ j(not_zero, &try_float, not_taken);
 
-  // Enter runtime system if the value of the expression is zero
-  // to make sure that we switch between 0 and -0.
-  __ test(eax, Operand(eax));
+  // Optimistically negate.  There are two special case.  (1) The
+  // smallest Smi value will overflow. (2) 0 should yield -0.  Both of
+  // these cases enter the runtime system.  No restoration of the
+  // operand's original value is necessary, as the two values are (the
+  // only) values such that x == -x in two's complement arithmetic.
+  __ neg(eax);
+  __ j(overflow, &slow, not_taken);
   __ j(zero, &slow, not_taken);
 
-  // The value of the expression is a smi that is not zero.  Try
-  // optimistic subtraction '0 - value'.
-  __ mov(edx, Operand(eax));
-  __ Set(eax, Immediate(0));
-  __ sub(eax, Operand(edx));
-  __ j(overflow, &undo, not_taken);
-
-  // If result is a smi we are done.
-  __ test(eax, Immediate(kSmiTagMask));
-  __ j(zero, &done, taken);
+  __ StubReturn(1);
 
   // Restore eax and enter runtime system.
   __ bind(&undo);
   __ mov(eax, Operand(edx));
 
   // Enter runtime system.
   __ bind(&slow);
   __ pop(ecx);  // pop return address
   __ push(eax);
   __ push(ecx);  // push return address
@@ skipping 13 matching lines @@
     // edx: operand
     __ AllocateHeapNumber(eax, ebx, ecx, &undo);
     // eax: allocated 'empty' number
     __ mov(ecx, FieldOperand(edx, HeapNumber::kExponentOffset));
     __ xor_(ecx, HeapNumber::kSignMask);  // Flip sign.
     __ mov(FieldOperand(eax, HeapNumber::kExponentOffset), ecx);
     __ mov(ecx, FieldOperand(edx, HeapNumber::kMantissaOffset));
     __ mov(FieldOperand(eax, HeapNumber::kMantissaOffset), ecx);
   }
 
-  __ bind(&done);
-
   __ StubReturn(1);
 }
 
 
 void ArgumentsAccessStub::GenerateReadLength(MacroAssembler* masm) {
   // Check if the calling frame is an arguments adaptor frame.
   Label adaptor;
   __ mov(edx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
   __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
   __ cmp(Operand(ecx), Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
@@ skipping 1084 matching lines @@
     __ add(Operand(dest), Immediate(2));
   }
   __ sub(Operand(count), Immediate(1));
   __ j(not_zero, &loop);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal