A64: Move veneer emission checking in the Assembler.

src/a64/full-codegen-a64.cc

 // Copyright 2013 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 75 matching lines @@
   }
 
   void EmitJumpIfEitherNotSmi(Register reg1, Register reg2, Label* target) {
     // We need to use ip0, so don't allow access to the MacroAssembler.
     InstructionAccurateScope scope(masm_);
     __ orr(ip0, reg1, reg2);
     EmitJumpIfNotSmi(ip0, target);
   }
 
   void EmitPatchInfo() {
-    Assembler::BlockConstPoolScope scope(masm_);
+    Assembler::BlockPoolsScope scope(masm_);
     InlineSmiCheckInfo::Emit(masm_, reg_, &patch_site_);
 #ifdef DEBUG
     info_emitted_ = true;
 #endif
   }
 
  private:
   MacroAssembler* masm_;
   Label patch_site_;
   Register reg_;
@@ skipping 236 matching lines @@
   __ Mov(x3, Operand(Smi::FromInt(reset_value)));
   __ Str(x3, FieldMemOperand(x2, Cell::kValueOffset));
 }
 
 
 void FullCodeGenerator::EmitBackEdgeBookkeeping(IterationStatement* stmt,
                                                 Label* back_edge_target) {
   ASSERT(jssp.Is(__ StackPointer()));
   Comment cmnt(masm_, "[ Back edge bookkeeping");
   // Block literal pools whilst emitting back edge code.
-  Assembler::BlockConstPoolScope block_const_pool(masm_);
+  Assembler::BlockPoolsScope block_const_pool(masm_);
   Label ok;
 
   ASSERT(back_edge_target->is_bound());
   int distance = masm_->SizeOfCodeGeneratedSince(back_edge_target);
   int weight = Min(kMaxBackEdgeWeight,
                    Max(1, distance / kCodeSizeMultiplier));
   EmitProfilingCounterDecrement(weight);
   __ B(pl, &ok);
   __ Call(isolate()->builtins()->InterruptCheck(), RelocInfo::CODE_TARGET);
 
@@ skipping 1636 matching lines @@
   __ Pop(left);
 
   // Perform combined smi check on both operands.
   __ Orr(x10, left, right);
   JumpPatchSite patch_site(masm_);
   patch_site.EmitJumpIfSmi(x10, &both_smis);
 
   __ Bind(&stub_call);
   BinaryOpICStub stub(op, mode);
   {
-    Assembler::BlockConstPoolScope scope(masm_);
+    Assembler::BlockPoolsScope scope(masm_);
     CallIC(stub.GetCode(isolate()), expr->BinaryOperationFeedbackId());
     patch_site.EmitPatchInfo();
   }
   __ B(&done);
 
   __ Bind(&both_smis);
   // Smi case. This code works in the same way as the smi-smi case in the type
   // recording binary operation stub, see
   // BinaryOpStub::GenerateSmiSmiOperation for comments.
   // TODO(all): That doesn't exist any more. Where are the comments?
@@ skipping 65 matching lines @@
 }
 
 
 void FullCodeGenerator::EmitBinaryOp(BinaryOperation* expr,
                                      Token::Value op,
                                      OverwriteMode mode) {
   __ Pop(x1);
   BinaryOpICStub stub(op, mode);
   JumpPatchSite patch_site(masm_);    // Unbound, signals no inlined smi code.
   {
-    Assembler::BlockConstPoolScope scope(masm_);
+    Assembler::BlockPoolsScope scope(masm_);
     CallIC(stub.GetCode(isolate()), expr->BinaryOperationFeedbackId());
     patch_site.EmitPatchInfo();
   }
   context()->Plug(x0);
 }
 
 
 void FullCodeGenerator::EmitAssignment(Expression* expr) {
   // Invalid left-hand sides are rewritten to have a 'throw
   // ReferenceError' on the left-hand side.
@@ skipping 2003 matching lines @@
   }
 
   __ Bind(&stub_call);
   __ Mov(x1, x0);
   __ Mov(x0, Operand(Smi::FromInt(count_value)));
 
   // Record position before stub call.
   SetSourcePosition(expr->position());
 
   {
-    Assembler::BlockConstPoolScope scope(masm_);
+    Assembler::BlockPoolsScope scope(masm_);
     BinaryOpICStub stub(Token::ADD, NO_OVERWRITE);
     CallIC(stub.GetCode(isolate()), expr->CountBinOpFeedbackId());
     patch_site.EmitPatchInfo();
   }
   __ Bind(&done);
 
   // Store the value returned in x0.
   switch (assign_type) {
     case VARIABLE:
       if (expr->is_postfix()) {
@@ skipping 853 matching lines @@
   return previous_;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64