Experimental: periodic merge of the bleeding_edge branch to the...

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 991 matching lines @@
                                  Handle<Object> value,
                                  bool reversed,
                                  OverwriteMode overwrite_mode) {
   // NOTE: This is an attempt to inline (a bit) more of the code for
   // some possible smi operations (like + and -) when (at least) one
   // of the operands is a literal smi. With this optimization, the
   // performance of the system is increased by ~15%, and the generated
   // code size is increased by ~1% (measured on a combination of
   // different benchmarks).
 
-  // TODO(1217802): Optimize some special cases of operations
-  // involving a smi literal (multiply by 2, shift by 0, etc.).
+  // TODO(199): Optimize some special cases of operations involving a
+  // smi literal (multiply by 2, shift by 0, etc.).
 
   // Get the literal value.
   Smi* smi_value = Smi::cast(*value);
   int int_value = smi_value->value();
   ASSERT(is_intn(int_value, kMaxSmiInlinedBits));
 
   switch (op) {
     case Token::ADD: {
       DeferredCode* deferred = NULL;
       if (!reversed) {
@@ skipping 126 matching lines @@
         new DeferredInlinedSmiOperation(this, Token::SHL, smi_value,
                                         overwrite_mode);
         Result operand = frame_->Pop();
         operand.ToRegister();
         __ test(operand.reg(), Immediate(kSmiTagMask));
         deferred->enter()->Branch(not_zero, &operand, not_taken);
         Result answer = allocator()->Allocate();
         ASSERT(answer.is_valid());
         __ mov(answer.reg(), Operand(operand.reg()));
         ASSERT(kSmiTag == 0);  // adjust code if not the case
+        // We do no shifts, only the Smi conversion, if shift_value is 1.
         if (shift_value == 0) {
           __ sar(answer.reg(), kSmiTagSize);
         } else if (shift_value > 1) {
           __ shl(answer.reg(), shift_value - 1);
-        }  // We do no shifts, only the Smi conversion, if shift_value is 1.
+        }
         // Convert int result to Smi, checking that it is in int range.
         ASSERT(kSmiTagSize == times_2);  // adjust code if not the case
         __ add(answer.reg(), Operand(answer.reg()));
         deferred->enter()->Branch(overflow, &operand, not_taken);
         operand.Unuse();
         deferred->exit()->Bind(&answer);
         frame_->Push(&answer);
       }
       break;
     }
@@ skipping 1813 matching lines @@
 
   // Push the literal.
   frame_->EmitPush(ebx);
   // Clone the boilerplate object.
   frame_->CallRuntime(Runtime::kCloneObjectLiteralBoilerplate, 1);
   // Push the new cloned literal object as the result.
   frame_->EmitPush(eax);
 
 
   for (int i = 0; i < node->properties()->length(); i++) {
-    ObjectLiteral::Property* property  = node->properties()->at(i);
+    ObjectLiteral::Property* property = node->properties()->at(i);
     switch (property->kind()) {
       case ObjectLiteral::Property::CONSTANT: break;
       case ObjectLiteral::Property::COMPUTED: {
         Handle<Object> key(property->key()->handle());
         Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
         if (key->IsSymbol()) {
           __ mov(eax, frame_->Top());
           frame_->EmitPush(eax);
           LoadAndSpill(property->value());
           frame_->EmitPop(eax);
@@ skipping 82 matching lines @@
       int offset = i * kPointerSize + Array::kHeaderSize;
       __ mov(FieldOperand(ecx, offset), eax);
 
       // Update the write barrier for the array address.
       __ RecordWrite(ecx, offset, eax, ebx);
     }
   }
 }
 
 
+void CodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* node) {
+  // Call runtime routine to allocate the catch extension object and
+  // assign the exception value to the catch variable.
+  Comment cmnt(masm_, "[CatchExtensionObject ");
+  Load(node->key());
+  Load(node->value());
+  __ CallRuntime(Runtime::kCreateCatchExtensionObject, 2);
+  frame_->Push(eax);
+}
+
+
 bool CodeGenerator::IsInlineSmi(Literal* literal) {
   if (literal == NULL || !literal->handle()->IsSmi()) return false;
   int int_value = Smi::cast(*literal->handle())->value();
   return is_intn(int_value, kMaxSmiInlinedBits);
 }
 
 
 void CodeGenerator::VisitAssignment(Assignment* node) {
   Comment cmnt(masm_, "[ Assignment");
   CodeForStatementPosition(node);
@@ skipping 2060 matching lines @@
           // - 0x80000000: high bit would be lost when smi tagging.
           // - 0x40000000: this number would convert to negative when
           // Smi tagging these two cases can only happen with shifts
           // by 0 or 1 when handed a valid smi.
           __ test(eax, Immediate(0xc0000000));
           __ j(not_zero, slow, not_taken);
           break;
         case Token::SHL:
           __ shl(eax);
           // Check that the *signed* result fits in a smi.
-          __ lea(ecx, Operand(eax, 0x40000000));
-          __ test(ecx, Immediate(0x80000000));
-          __ j(not_zero, slow, not_taken);
+          __ cmp(eax, 0xc0000000);
+          __ j(sign, slow, not_taken);
           break;
         default:
           UNREACHABLE();
       }
       // Tag the result and store it in register eax.
       ASSERT(kSmiTagSize == times_2);  // adjust code if not the case
       __ lea(eax, Operand(eax, eax, times_1, kSmiTag));
       break;
 
     default:
@@ skipping 1019 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal