Experimental: more stuff to get ARM to work. Stubbed out frame merge...

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 768 matching lines @@
     frame_->Push(&answer);
   } else {
     // Call the stub and push the result to the stack.
     GenericBinaryOpStub stub(op, overwrite_mode, flags);
     Result answer = frame_->CallStub(&stub, 2);
     frame_->Push(&answer);
   }
 }
 
 
-class DeferredInlinedSmiOperation: public DeferredCode {
+class DeferredInlineSmiOperation: public DeferredCode {
  public:
-  DeferredInlinedSmiOperation(CodeGenerator* generator,
+  DeferredInlineSmiOperation(CodeGenerator* generator,
                               Token::Value op,
                               Smi* value,
                               OverwriteMode overwrite_mode)
       : DeferredCode(generator),
         op_(op),
         value_(value),
         overwrite_mode_(overwrite_mode) {
-    set_comment("[ DeferredInlinedSmiOperation");
+    set_comment("[ DeferredInlineSmiOperation");
   }
 
   virtual void Generate();
 
  private:
   Token::Value op_;
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
-void DeferredInlinedSmiOperation::Generate() {
+void DeferredInlineSmiOperation::Generate() {
   Result left(generator());
   enter()->Bind(&left);
   generator()->frame()->Push(&left);
   generator()->frame()->Push(value_);
   GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
   exit()->Jump(&answer);
 }
 
 
-class DeferredInlinedSmiOperationReversed: public DeferredCode {
+class DeferredInlineSmiOperationReversed: public DeferredCode {
  public:
-  DeferredInlinedSmiOperationReversed(CodeGenerator* generator,
-                                      Token::Value op,
-                                      Smi* value,
-                                      OverwriteMode overwrite_mode)
+  DeferredInlineSmiOperationReversed(CodeGenerator* generator,
+                                     Token::Value op,
+                                     Smi* value,
+                                     OverwriteMode overwrite_mode)
       : DeferredCode(generator),
         op_(op),
         value_(value),
         overwrite_mode_(overwrite_mode) {
-    set_comment("[ DeferredInlinedSmiOperationReversed");
+    set_comment("[ DeferredInlineSmiOperationReversed");
   }
 
   virtual void Generate();
 
  private:
   Token::Value op_;
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
-void DeferredInlinedSmiOperationReversed::Generate() {
+void DeferredInlineSmiOperationReversed::Generate() {
   Result right(generator());
   enter()->Bind(&right);
   generator()->frame()->Push(value_);
   generator()->frame()->Push(&right);
   GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
   exit()->Jump(&answer);
 }
 
 
-class DeferredInlinedSmiAdd: public DeferredCode {
+class DeferredInlineSmiAdd: public DeferredCode {
  public:
-  DeferredInlinedSmiAdd(CodeGenerator* generator,
-                        Smi* value,
-                        OverwriteMode overwrite_mode)
+  DeferredInlineSmiAdd(CodeGenerator* generator,
+                       Smi* value,
+                       OverwriteMode overwrite_mode)
       : DeferredCode(generator),
         value_(value),
         overwrite_mode_(overwrite_mode) {
-    set_comment("[ DeferredInlinedSmiAdd");
+    set_comment("[ DeferredInlineSmiAdd");
   }
 
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
-void DeferredInlinedSmiAdd::Generate() {
+void DeferredInlineSmiAdd::Generate() {
   // Undo the optimistic add operation and call the shared stub.
   Result left(generator());  // Initially left + value_.
   enter()->Bind(&left);
   left.ToRegister();
   generator()->frame()->Spill(left.reg());
   __ sub(Operand(left.reg()), Immediate(value_));
   generator()->frame()->Push(&left);
   generator()->frame()->Push(value_);
   GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
   exit()->Jump(&answer);
 }
 
 
-class DeferredInlinedSmiAddReversed: public DeferredCode {
+class DeferredInlineSmiAddReversed: public DeferredCode {
  public:
-  DeferredInlinedSmiAddReversed(CodeGenerator* generator,
-                                Smi* value,
-                                OverwriteMode overwrite_mode)
+  DeferredInlineSmiAddReversed(CodeGenerator* generator,
+                               Smi* value,
+                               OverwriteMode overwrite_mode)
       : DeferredCode(generator),
         value_(value),
         overwrite_mode_(overwrite_mode) {
-    set_comment("[ DeferredInlinedSmiAddReversed");
+    set_comment("[ DeferredInlineSmiAddReversed");
   }
 
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
-void DeferredInlinedSmiAddReversed::Generate() {
+void DeferredInlineSmiAddReversed::Generate() {
   // Undo the optimistic add operation and call the shared stub.
   Result right(generator());  // Initially value_ + right.
   enter()->Bind(&right);
   right.ToRegister();
   generator()->frame()->Spill(right.reg());
   __ sub(Operand(right.reg()), Immediate(value_));
   generator()->frame()->Push(value_);
   generator()->frame()->Push(&right);
   GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
   exit()->Jump(&answer);
 }
 
 
-class DeferredInlinedSmiSub: public DeferredCode {
+class DeferredInlineSmiSub: public DeferredCode {
  public:
-  DeferredInlinedSmiSub(CodeGenerator* generator,
-                        Smi* value,
-                        OverwriteMode overwrite_mode)
+  DeferredInlineSmiSub(CodeGenerator* generator,
+                       Smi* value,
+                       OverwriteMode overwrite_mode)
       : DeferredCode(generator),
         value_(value),
         overwrite_mode_(overwrite_mode) {
-    set_comment("[ DeferredInlinedSmiSub");
+    set_comment("[ DeferredInlineSmiSub");
   }
 
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
-void DeferredInlinedSmiSub::Generate() {
+void DeferredInlineSmiSub::Generate() {
   // Undo the optimistic sub operation and call the shared stub.
   Result left(generator());  // Initially left - value_.
   enter()->Bind(&left);
   left.ToRegister();
   generator()->frame()->Spill(left.reg());
   __ add(Operand(left.reg()), Immediate(value_));
   generator()->frame()->Push(&left);
   generator()->frame()->Push(value_);
   GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
   exit()->Jump(&answer);
 }
 
 
-class DeferredInlinedSmiSubReversed: public DeferredCode {
+class DeferredInlineSmiSubReversed: public DeferredCode {
  public:
-  DeferredInlinedSmiSubReversed(CodeGenerator* generator,
-                                Smi* value,
-                                OverwriteMode overwrite_mode)
+  DeferredInlineSmiSubReversed(CodeGenerator* generator,
+                               Smi* value,
+                               OverwriteMode overwrite_mode)
       : DeferredCode(generator),
         value_(value),
         overwrite_mode_(overwrite_mode) {
-    set_comment("[ DeferredInlinedSmiSubReversed");
+    set_comment("[ DeferredInlineSmiSubReversed");
   }
 
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
-void DeferredInlinedSmiSubReversed::Generate() {
+void DeferredInlineSmiSubReversed::Generate() {
   // Call the shared stub.
   Result right(generator());
   enter()->Bind(&right);
   generator()->frame()->Push(value_);
   generator()->frame()->Push(&right);
   GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
   exit()->Jump(&answer);
 }
 
@@ skipping 15 matching lines @@
 
   // 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) {
-        deferred = new DeferredInlinedSmiAdd(this, smi_value, overwrite_mode);
+        deferred = new DeferredInlineSmiAdd(this, smi_value, overwrite_mode);
       } else {
-        deferred = new DeferredInlinedSmiAddReversed(this, smi_value,
-                                                     overwrite_mode);
+        deferred = new DeferredInlineSmiAddReversed(this, smi_value,
+                                                    overwrite_mode);
       }
       Result operand = frame_->Pop();
       operand.ToRegister();
       frame_->Spill(operand.reg());
       __ add(Operand(operand.reg()), Immediate(value));
       deferred->enter()->Branch(overflow, &operand, not_taken);
       __ test(Operand(operand.reg()), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, &operand, not_taken);
       deferred->exit()->Bind(&operand);
       frame_->Push(&operand);
       break;
     }
 
     case Token::SUB: {
       DeferredCode* deferred = NULL;
       Result operand = frame_->Pop();
       Result answer(this);  // Only allocated a new register if reversed.
       if (!reversed) {
         operand.ToRegister();
         frame_->Spill(operand.reg());
-        deferred = new DeferredInlinedSmiSub(this,
-                                             smi_value,
-                                             overwrite_mode);
+        deferred = new DeferredInlineSmiSub(this,
+                                            smi_value,
+                                            overwrite_mode);
         __ sub(Operand(operand.reg()), Immediate(value));
         answer = operand;
       } else {
         answer = allocator()->Allocate();
         ASSERT(answer.is_valid());
-        deferred = new DeferredInlinedSmiSubReversed(this,
-                                                     smi_value,
-                                                     overwrite_mode);
+        deferred = new DeferredInlineSmiSubReversed(this,
+                                                    smi_value,
+                                                    overwrite_mode);
         __ mov(answer.reg(), Immediate(value));
         if (operand.is_register()) {
           __ sub(answer.reg(), Operand(operand.reg()));
         } else {
           ASSERT(operand.is_constant());
           __ sub(Operand(answer.reg()), Immediate(operand.handle()));
         }
       }
       deferred->enter()->Branch(overflow, &operand, not_taken);
       __ test(answer.reg(), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, &operand, not_taken);
       operand.Unuse();
       deferred->exit()->Bind(&answer);
       frame_->Push(&answer);
       break;
     }
 
     case Token::SAR: {
       if (reversed) {
         Result top = frame_->Pop();
         frame_->Push(value);
         frame_->Push(&top);
         GenericBinaryOperation(op, type, 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;
         DeferredCode* deferred =
-          new DeferredInlinedSmiOperation(this, Token::SAR, smi_value,
-                                          overwrite_mode);
+          new DeferredInlineSmiOperation(this, Token::SAR, smi_value,
+                                         overwrite_mode);
         Result result = frame_->Pop();
         result.ToRegister();
         __ test(result.reg(), Immediate(kSmiTagMask));
         deferred->enter()->Branch(not_zero, &result, not_taken);
         frame_->Spill(result.reg());
         __ sar(result.reg(), shift_value);
         __ and_(result.reg(), ~kSmiTagMask);
         deferred->exit()->Bind(&result);
         frame_->Push(&result);
       }
       break;
     }
 
     case Token::SHR: {
       if (reversed) {
         Result top = frame_->Pop();
         frame_->Push(value);
         frame_->Push(&top);
         GenericBinaryOperation(op, type, 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;
         DeferredCode* deferred =
-        new DeferredInlinedSmiOperation(this, Token::SHR, smi_value,
-                                        overwrite_mode);
+        new DeferredInlineSmiOperation(this, Token::SHR, 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()));
         __ sar(answer.reg(), kSmiTagSize);
         __ shr(answer.reg(), shift_value);
         // A negative Smi shifted right two is in the positive Smi range.
@@ skipping 15 matching lines @@
       if (reversed) {
         Result top = frame_->Pop();
         frame_->Push(value);
         frame_->Push(&top);
         GenericBinaryOperation(op, type, 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;
         DeferredCode* deferred =
-        new DeferredInlinedSmiOperation(this, Token::SHL, smi_value,
-                                        overwrite_mode);
+        new DeferredInlineSmiOperation(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) {
@@ skipping 10 matching lines @@
         frame_->Push(&answer);
       }
       break;
     }
 
     case Token::BIT_OR:
     case Token::BIT_XOR:
     case Token::BIT_AND: {
       DeferredCode* deferred = NULL;
       if (!reversed) {
-        deferred =  new DeferredInlinedSmiOperation(this, op, smi_value,
-                                                    overwrite_mode);
+        deferred =  new DeferredInlineSmiOperation(this, op, smi_value,
+                                                   overwrite_mode);
       } else {
-        deferred = new DeferredInlinedSmiOperationReversed(this, op, smi_value,
-                                                           overwrite_mode);
+        deferred = new DeferredInlineSmiOperationReversed(this, op, smi_value,
+                                                          overwrite_mode);
       }
       Result operand = frame_->Pop();
       operand.ToRegister();
       __ test(operand.reg(), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, &operand, not_taken);
       frame_->Spill(operand.reg());
       if (op == Token::BIT_AND) {
         __ and_(Operand(operand.reg()), Immediate(value));
       } else if (op == Token::BIT_XOR) {
         __ xor_(Operand(operand.reg()), Immediate(value));
@@ skipping 964 matching lines @@
         }
         if (node->break_target()->is_linked()) {
           node->break_target()->Bind();
         }
 
       } else {
         ASSERT(info == DONT_KNOW);
         // We have to compile the test expression if it can be reached by
         // control flow falling out of the body or via continue.
         if (node->continue_target()->is_linked()) {
-        node->continue_target()->Bind();
+          node->continue_target()->Bind();
         }
         if (has_valid_frame()) {
           ControlDestination dest(&body, node->break_target(), false);
           LoadCondition(node->cond(), NOT_INSIDE_TYPEOF, &dest, true);
         }
         if (node->break_target()->is_linked()) {
           node->break_target()->Bind();
         }
       }
       break;
@@ skipping 1418 matching lines @@
   ASSERT(function.is_valid());
 
   // Call the construct call builtin that handles allocation and
   // constructor invocation.
   CodeForSourcePosition(node->position());
   Handle<Code> ic(Builtins::builtin(Builtins::JSConstructCall));
   Result result = frame_->CallCodeObject(ic,
                                          RelocInfo::CONSTRUCT_CALL,
                                          &num_args,
                                          &function,
-                                         args->length() + 1);
+                                         arg_count + 1);
 
   // Replace the function on the stack with the result.
   frame_->SetElementAt(0, &result);
 }
 
 
 void CodeGenerator::VisitCallEval(CallEval* node) {
   Comment cmnt(masm_, "[ CallEval");
 
   // In a call to eval, we first call %ResolvePossiblyDirectEval to resolve
@@ skipping 2934 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal