Replace long sequences of popq with a Drop(int) macro instruction.

vm/flow_graph_compiler_x64.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 330 matching lines @@
     __ pushq(RDX);  // Instantiator type arguments.
   }
   __ PushObject(dst_name);  // Push the name of the destination.
   __ pushq(raw_null);  // SubtypeTestCache not yet supported.
   GenerateCallRuntime(cid,
                       token_index,
                       try_index,
                       kTypeCheckRuntimeEntry);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
-  __ addq(RSP, Immediate(8 * kWordSize));
+  __ Drop(8);
   __ popq(RAX);
 
   __ Bind(&is_assignable);
 }
 
 
 void FlowGraphCompiler::LoadValue(Register dst, Value* value) {
   if (value->IsConstant()) {
     ConstantVal* constant = value->AsConstant();
     if (constant->value().IsSmi()) {
@@ skipping 110 matching lines @@
       break;
     case 2:
       label_address = StubCode::TwoArgsCheckInlineCacheEntryPoint();
       break;
     default:
       UNIMPLEMENTED();
   }
   ExternalLabel target_label("InlineCache", label_address);
   __ call(&target_label);
   AddCurrentDescriptor(PcDescriptors::kIcCall, cid, token_index, try_index);
-  __ addq(RSP, Immediate(argument_count * kWordSize));
+  __ Drop(argument_count);
 }
 
 
 void FlowGraphCompiler::EmitStaticCall(intptr_t token_index,
                                        intptr_t try_index,
                                        const Function& function,
                                        intptr_t argument_count,
                                        const Array& argument_names) {
   const Array& arguments_descriptor =
       CodeGenerator::ArgumentsDescriptor(argument_count, argument_names);
   __ LoadObject(RBX, function);
   __ LoadObject(R10, arguments_descriptor);
 
   GenerateCall(token_index,
                try_index,
                &StubCode::CallStaticFunctionLabel(),
                PcDescriptors::kFuncCall);
-  __ addq(RSP, Immediate(argument_count * kWordSize));
+  __ Drop(argument_count);
 }
 
 
 void FlowGraphCompiler::VisitCurrentContext(CurrentContextComp* comp) {
   __ movq(RAX, CTX);
 }
 
 
 void FlowGraphCompiler::VisitStoreContext(StoreContextComp* comp) {
   LoadValue(CTX, comp->value());
 }
 
 
 void FlowGraphCompiler::VisitClosureCall(ClosureCallComp* comp) {
   ASSERT(comp->context()->IsUse());
   ASSERT(VerifyCallComputation(comp));
   // The arguments to the stub include the closure.  The arguments
   // descriptor describes the closure's arguments (and so does not include
   // the closure).
   int argument_count = comp->ArgumentCount();
   const Array& arguments_descriptor =
       CodeGenerator::ArgumentsDescriptor(argument_count - 1,
                                          comp->argument_names());
   __ LoadObject(R10, arguments_descriptor);
 
   GenerateCall(comp->token_index(),
                comp->try_index(),
                &StubCode::CallClosureFunctionLabel(),
                PcDescriptors::kOther);
-  __ addq(RSP, Immediate(argument_count * kWordSize));
+  __ Drop(argument_count);
   __ popq(CTX);
 }
 
 
 void FlowGraphCompiler::VisitInstanceCall(InstanceCallComp* comp) {
   ASSERT(VerifyCallComputation(comp));
   EmitInstanceCall(comp->cid(),
                    comp->token_index(),
                    comp->try_index(),
                    comp->function_name(),
@@ skipping 288 matching lines @@
   __ pushq(raw_null);  // TODO(srdjan): Pass instantiator instead of null.
   if (type.IsInstantiated()) {
     __ pushq(raw_null);  // Null instantiator type arguments.
   } else {
     __ pushq(RDX);  // Instantiator type arguments.
   }
   __ pushq(raw_null);  // SubtypeTestCache not yet supported.
   GenerateCallRuntime(cid, token_index, try_index, kInstanceofRuntimeEntry);
   // Pop the two parameters supplied to the runtime entry. The result of the
   // instanceof runtime call will be left as the result of the operation.
-  __ addq(RSP, Immediate(7 * kWordSize));
+  __ Drop(7);
   Label done;
   if (negate_result) {
     __ popq(RDX);
     __ LoadObject(RAX, bool_true);
     __ cmpq(RDX, RAX);
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     __ LoadObject(RAX, bool_false);
   } else {
     __ popq(RAX);
   }
@@ skipping 21 matching lines @@
                      comp->negate_result());
 }
 
 
 void FlowGraphCompiler::VisitAllocateObject(AllocateObjectComp* comp) {
   const Class& cls = Class::ZoneHandle(comp->constructor().owner());
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
   const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
   GenerateCall(comp->token_index(), comp->try_index(), &label,
                PcDescriptors::kOther);
-  for (intptr_t i = 0; i < comp->arguments().length(); i++) {
-    __ popq(RCX);  // Discard allocation argument
-  }
+  __ Drop(comp->arguments().length());  // Discard allocation argument.
 }
 
 
 void FlowGraphCompiler::VisitAllocateObjectWithBoundsCheck(
     AllocateObjectWithBoundsCheckComp* comp) {
   const Class& cls = Class::ZoneHandle(comp->constructor().owner());
   __ popq(RCX);  // Pop instantiator type arguments.
   __ popq(RAX);  // Pop type arguments.
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ pushq(Immediate(Smi::RawValue(comp->token_index())));
   __ PushObject(cls);
   __ pushq(RAX);  // Push type arguments.
   __ pushq(RCX);  // Push instantiator type arguments.
   GenerateCallRuntime(comp->cid(),
                       comp->token_index(),
                       comp->try_index(),
                       kAllocateObjectWithBoundsCheckRuntimeEntry);
-  __ popq(RCX);  // Pop instantiator type arguments.
-  __ popq(RCX);  // Pop type arguments.
-  __ popq(RCX);  // Pop class.
-  __ popq(RCX);  // Pop source location.
+  // Pop instantiator type arguments, type arguments, class, and
+  // source location.
+  __ Drop(4);
   __ popq(RAX);  // Pop new instance.
 }
 
 
 void FlowGraphCompiler::VisitCreateArray(CreateArrayComp* comp) {
   // 1. Allocate the array.  R10 = length, RBX = element type.
   __ movq(R10, Immediate(Smi::RawValue(comp->ElementCount())));
   LoadValue(RBX, comp->element_type());
   GenerateCall(comp->token_index(),
                comp->try_index(),
@@ skipping 794 matching lines @@
   ASSERT(exception_handlers_list_ != NULL);
   const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
       exception_handlers_list_->FinalizeExceptionHandlers(code.EntryPoint()));
   code.set_exception_handlers(handlers);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64