Experimental: introduce a simple mechanism to allow jump targets with...

src/codegen-arm.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 767 matching lines @@
       UNREACHABLE();
       break;
   }
 
   GenericBinaryOpStub igostub(op_);
   Result arg0 = generator()->allocator()->Allocate(r0);
   ASSERT(arg0.is_valid());
   Result arg1 = generator()->allocator()->Allocate(r1);
   ASSERT(arg1.is_valid());
   generator()->frame()->CallStub(&igostub, &arg0, &arg1, 0);
-  exit()->Jump();
+  exit_.Jump();
 }
 
 
 void CodeGenerator::SmiOperation(Token::Value op,
                                  Handle<Object> value,
                                  bool reversed) {
   VirtualFrame::SpilledScope spilled_scope(this);
   // 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
@@ skipping 10 matching lines @@
 
   switch (op) {
     case Token::ADD: {
       DeferredCode* deferred =
         new DeferredInlineSmiOperation(this, op, int_value, reversed);
 
       __ add(r0, r0, Operand(value), SetCC);
       deferred->enter()->Branch(vs);
       __ tst(r0, Operand(kSmiTagMask));
       deferred->enter()->Branch(ne);
-      deferred->exit()->Bind();
+      deferred->BindExit();
       break;
     }
 
     case Token::SUB: {
       DeferredCode* deferred =
         new DeferredInlineSmiOperation(this, op, int_value, reversed);
 
       if (!reversed) {
         __ sub(r0, r0, Operand(value), SetCC);
       } else {
         __ rsb(r0, r0, Operand(value), SetCC);
       }
       deferred->enter()->Branch(vs);
       __ tst(r0, Operand(kSmiTagMask));
       deferred->enter()->Branch(ne);
-      deferred->exit()->Bind();
+      deferred->BindExit();
       break;
     }
 
     case Token::BIT_OR:
     case Token::BIT_XOR:
     case Token::BIT_AND: {
       DeferredCode* deferred =
         new DeferredInlineSmiOperation(this, op, int_value, reversed);
       __ tst(r0, Operand(kSmiTagMask));
       deferred->enter()->Branch(ne);
       switch (op) {
         case Token::BIT_OR:  __ orr(r0, r0, Operand(value)); break;
         case Token::BIT_XOR: __ eor(r0, r0, Operand(value)); break;
         case Token::BIT_AND: __ and_(r0, r0, Operand(value)); break;
         default: UNREACHABLE();
       }
-      deferred->exit()->Bind();
+      deferred->BindExit();
       break;
     }
 
     case Token::SHL:
     case Token::SHR:
     case Token::SAR: {
       if (reversed) {
         __ mov(ip, Operand(value));
         frame_->EmitPush(ip);
         frame_->EmitPush(r0);
@@ skipping 32 matching lines @@
           case Token::SAR: {
             if (shift_value != 0) {
               // ASR by immediate 0 means shifting 32 bits.
               __ mov(r2, Operand(r2, ASR, shift_value));
             }
             break;
           }
           default: UNREACHABLE();
         }
         __ mov(r0, Operand(r2, LSL, kSmiTagSize));
-        deferred->exit()->Bind();
+        deferred->BindExit();
       }
       break;
     }
 
     default:
       if (!reversed) {
         frame_->EmitPush(r0);
         __ mov(r0, Operand(value));
         frame_->EmitPush(r0);
       } else {
@@ skipping 1422 matching lines @@
   // Literal index (1).
   __ mov(r0, Operand(Smi::FromInt(node_->literal_index())));
   frame->EmitPush(r0);
   // Constant properties (2).
   __ mov(r0, Operand(node_->constant_properties()));
   frame->EmitPush(r0);
   Result boilerplate =
       frame->CallRuntime(Runtime::kCreateObjectLiteralBoilerplate, 3);
   __ mov(r2, Operand(boilerplate.reg()));
   // Result is returned in r2.
-  exit()->Jump();
+  exit_.Jump();
 }
 
 
 void CodeGenerator::VisitObjectLiteral(ObjectLiteral* node) {
   VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ ObjectLiteral");
 
   DeferredObjectLiteral* deferred = new DeferredObjectLiteral(this, node);
 
   // Retrieve the literal array and check the allocated entry.
 
   // Load the function of this activation.
   __ ldr(r1, frame_->Function());
 
   // Load the literals array of the function.
   __ ldr(r1, FieldMemOperand(r1, JSFunction::kLiteralsOffset));
 
   // Load the literal at the ast saved index.
   int literal_offset =
       FixedArray::kHeaderSize + node->literal_index() * kPointerSize;
   __ ldr(r2, FieldMemOperand(r1, literal_offset));
 
   // Check whether we need to materialize the object literal boilerplate.
   // If so, jump to the deferred code.
   __ cmp(r2, Operand(Factory::undefined_value()));
   deferred->enter()->Branch(eq);
-  deferred->exit()->Bind();
+  deferred->BindExit();
 
   // Push the object literal boilerplate.
   frame_->EmitPush(r2);
 
   // Clone the boilerplate object.
   frame_->CallRuntime(Runtime::kCloneObjectLiteralBoilerplate, 1);
   frame_->EmitPush(r0);  // save the result
   // r0: cloned object literal
 
   for (int i = 0; i < node->properties()->length(); i++) {
@@ skipping 2322 matching lines @@
   __ mov(r2, Operand(0));
   __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION);
   __ Jump(Handle<Code>(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline)),
           RelocInfo::CODE_TARGET);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal