Remove the barely used macro assemblers after merging their contents to the base

runtime/vm/stub_code_ia32.cc

 // Copyright (c) 2013, 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"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
-#include "vm/assembler_macros.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/instructions.h"
 #include "vm/object_store.h"
 #include "vm/pages.h"
 #include "vm/resolver.h"
 #include "vm/scavenger.h"
 #include "vm/stub_code.h"
 
@@ skipping 161 matching lines @@
   __ LeaveFrame();
   __ ret();
 }
 
 
 // Input parameters:
 //   EDX: arguments descriptor array.
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ CallRuntime(kPatchStaticCallRuntimeEntry);
   __ popl(EAX);  // Get Code object result.
   __ popl(EDX);  // Restore arguments descriptor array.
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveFrame();
 
   __ movl(ECX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(ECX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(ECX);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // EDX: arguments descriptor array.
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ CallRuntime(kFixCallersTargetRuntimeEntry);
   __ popl(EAX);  // Get Code object.
   __ popl(EDX);  // Restore arguments descriptor array.
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(EAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
   __ jmp(EAX);
   __ int3();
@@ skipping 30 matching lines @@
 
 
 // Input parameters:
 //   ECX: ic-data.
 //   EDX: arguments descriptor array.
 // Note: The receiver object is the first argument to the function being
 //       called, the stub accesses the receiver from this location directly
 //       when trying to resolve the call.
 // Uses EDI.
 void StubCode::GenerateInstanceFunctionLookupStub(Assembler* assembler) {
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
 
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ pushl(raw_null);  // Space for the return value.
 
   // Push the receiver as an argument.  Load the smi-tagged argument
   // count into EDI to index the receiver in the stack.  There are
   // three words (null, stub's pc marker, saved fp) above the return
   // address.
   __ movl(EDI, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
@@ skipping 109 matching lines @@
     // Restore result into EBX.
     __ movl(EBX, Address(EBP, -1 * kWordSize));
   }
   // Code above cannot cause GC.
   __ LeaveFrame();
   __ movl(EBP, EAX);
 
   // Frame is fully rewritten at this point and it is safe to perform a GC.
   // Materialize any objects that were deferred by FillFrame because they
   // require allocation.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   if (preserve_eax) {
     __ pushl(EBX);  // Preserve result, it will be GC-d here.
   }
   __ CallRuntime(kDeoptimizeMaterializeDoublesRuntimeEntry);
   if (preserve_eax) {
     __ popl(EAX);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
 }
@@ skipping 10 matching lines @@
   GenerateDeoptimizationSequence(assembler, true);  // Preserve EAX.
 }
 
 
 void StubCode::GenerateDeoptimizeStub(Assembler* assembler) {
   GenerateDeoptimizationSequence(assembler, false);  // Don't preserve EAX.
 }
 
 
 void StubCode::GenerateMegamorphicMissStub(Assembler* assembler) {
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   // Load the receiver into EAX.  The argument count in the arguments
   // descriptor in EDX is a smi.
   __ movl(EAX, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   // Two words (saved fp, stub's pc marker) in the stack above the return
   // address.
   __ movl(EAX, Address(ESP, EAX, TIMES_2, 2 * kWordSize));
   // Preserve IC data and arguments descriptor.
   __ pushl(ECX);
   __ pushl(EDX);
 
@@ skipping 143 matching lines @@
     // EAX: new object.
     // EDX: Array length as Smi (preserved for the caller.)
     __ ret();
   }
 
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EDX);  // Array length as Smi.
   __ pushl(ECX);  // Element type.
   __ CallRuntime(kAllocateArrayRuntimeEntry);
   __ popl(EAX);  // Pop element type argument.
   __ popl(EDX);  // Pop array length argument.
   __ popl(EAX);  // Pop return value from return slot.
   __ LeaveFrame();
   __ ret();
 }
@@ skipping 36 matching lines @@
   __ movl(CTX, FieldAddress(EDI, Closure::context_offset()));
 
   // Load closure function code in EAX.
   __ movl(EAX, FieldAddress(ECX, Function::code_offset()));
   __ cmpl(EAX, raw_null);
   Label function_compiled;
   __ j(NOT_EQUAL, &function_compiled, Assembler::kNearJump);
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
 
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(ECX);  // Preserve read-only function object argument.
   __ CallRuntime(kCompileFunctionRuntimeEntry);
   __ popl(ECX);  // Restore read-only function object argument in ECX.
   __ popl(EDX);  // Restore arguments descriptor array.
   // Restore EAX.
   __ movl(EAX, FieldAddress(ECX, Function::code_offset()));
 
   // Remove the stub frame as we are about to jump to the closure function.
@@ skipping 11 matching lines @@
   __ Bind(&not_closure);
   // Call runtime to attempt to resolve and invoke a call method on a
   // non-closure object, passing the non-closure object and its arguments array,
   // returning here.
   // If no call method exists, throw a NoSuchMethodError.
   // EDI: non-closure object.
   // EDX: arguments descriptor array.
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
 
   __ pushl(raw_null);  // Setup space on stack for result from error reporting.
   __ pushl(EDX);  // Arguments descriptor.
   // Load smi-tagged arguments array length, including the non-closure.
   __ movl(EDX, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   // See stack layout below explaining "wordSize * 5" offset.
   PushArgumentsArray(assembler, (kWordSize * 5));
 
   // Stack:
   // TOS + 0: Argument array.
@@ skipping 241 matching lines @@
     }
 
     // Done allocating and initializing the context.
     // EAX: new object.
     __ ret();
 
     __ Bind(&slow_case);
   }
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ SmiTag(EDX);
   __ pushl(EDX);
   __ CallRuntime(kAllocateContextRuntimeEntry);  // Allocate context.
   __ popl(EAX);  // Pop number of context variables argument.
   __ popl(EAX);  // Pop the new context object.
   // EAX: new object
   // Restore the frame pointer.
   __ LeaveFrame();
   __ ret();
@@ skipping 203 matching lines @@
     __ ret();
 
     __ Bind(&slow_case);
   }
   if (is_cls_parameterized) {
     __ movl(EAX, Address(ESP, kObjectTypeArgumentsOffset));
     __ movl(EDX, Address(ESP, kInstantiatorTypeArgumentsOffset));
   }
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ PushObject(cls);  // Push class of object to be allocated.
   if (is_cls_parameterized) {
     __ pushl(EAX);  // Push type arguments of object to be allocated.
     __ pushl(EDX);  // Push type arguments of instantiator.
   } else {
     __ pushl(raw_null);  // Push null type arguments.
     __ pushl(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
   __ CallRuntime(kAllocateObjectRuntimeEntry);  // Allocate object.
@@ skipping 119 matching lines @@
     __ Bind(&slow_case);
   }
   if (has_type_arguments) {
     __ movl(ECX, Address(ESP, kTypeArgumentsOffset));
   }
   if (is_implicit_instance_closure) {
     __ movl(EAX, Address(ESP, kReceiverOffset));
   }
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ PushObject(func);
   if (is_implicit_static_closure) {
     __ CallRuntime(kAllocateImplicitStaticClosureRuntimeEntry);
   } else {
     if (is_implicit_instance_closure) {
       __ pushl(EAX);  // Receiver.
     }
     if (has_type_arguments) {
       __ pushl(ECX);  // Push type arguments of closure to be allocated.
@@ skipping 33 matching lines @@
 void StubCode::GenerateCallNoSuchMethodFunctionStub(Assembler* assembler) {
   // The target function was not found, so invoke method
   // "dynamic noSuchMethod(InvocationMirror invocation)".
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ movl(EDI, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   __ movl(EAX, Address(EBP, EDI, TIMES_2, kWordSize));  // Get receiver.
 
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
 
   __ pushl(raw_null);  // Setup space on stack for result from noSuchMethod.
   __ pushl(EAX);  // Receiver.
   __ pushl(ECX);  // IC data array.
   __ pushl(EDX);  // Arguments descriptor array.
 
   __ movl(EDX, EDI);
   // See stack layout below explaining "wordSize * 10" offset.
   PushArgumentsArray(assembler, (kWordSize * 10));
 
@@ skipping 23 matching lines @@
   __ LeaveFrame();
   __ ret();
 }
 
 
 void StubCode::GenerateOptimizedUsageCounterIncrement(Assembler* assembler) {
   Register argdesc_reg = EDX;
   Register ic_reg = ECX;
   Register func_reg = EDI;
   if (FLAG_trace_optimized_ic_calls) {
-    AssemblerMacros::EnterStubFrame(assembler);
+    __ EnterStubFrame();
     __ pushl(func_reg);     // Preserve
     __ pushl(argdesc_reg);  // Preserve.
     __ pushl(ic_reg);       // Preserve.
     __ pushl(ic_reg);       // Argument.
     __ pushl(func_reg);     // Argument.
     __ CallRuntime(kTraceICCallRuntimeEntry);
     __ popl(EAX);          // Discard argument;
     __ popl(EAX);          // Discard argument;
     __ popl(ic_reg);       // Restore.
     __ popl(argdesc_reg);  // Restore.
@@ skipping 120 matching lines @@
 
   // IC miss.
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   // Compute address of arguments (first read number of arguments from
   // arguments descriptor array and then compute address on the stack).
   __ movl(EAX, FieldAddress(EDX, ArgumentsDescriptor::count_offset()));
   __ leal(EAX, Address(ESP, EAX, TIMES_2, 0));  // EAX is Smi.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(EDX);  // Preserve arguments descriptor array.
   __ pushl(ECX);  // Preserve IC data object.
   __ pushl(raw_null);  // Setup space on stack for result (target code object).
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
     __ movl(EBX, Address(EAX, -kWordSize * i));
     __ pushl(EBX);
   }
   __ pushl(ECX);  // Pass IC data object.
   __ pushl(EDX);  // Pass arguments descriptor array.
@@ skipping 131 matching lines @@
 void StubCode::GenerateMegamorphicCallStub(Assembler* assembler) {
   GenerateNArgsCheckInlineCacheStub(assembler, 1);
 }
 
 
 //  EDX: Arguments descriptor array.
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointStaticStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(EDX);  // Preserve arguments descriptor.
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ pushl(raw_null);  // Room for result.
   __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry);
   __ popl(EAX);  // Code object.
   __ popl(EDX);  // Restore arguments descriptor.
   __ LeaveFrame();
 
   // Now call the static function. The breakpoint handler function
   // ensures that the call target is compiled.
   __ movl(ECX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(ECX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(ECX);
 }
 
 
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointReturnStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(EAX);
   __ CallRuntime(kBreakpointReturnHandlerRuntimeEntry);
   __ popl(EAX);
   __ LeaveFrame();
 
   // Instead of returning to the patched Dart function, emulate the
   // smashed return code pattern and return to the function's caller.
   __ popl(ECX);  // Discard return address to patched dart code.
   // Execute function epilog code that was smashed in the Dart code.
   __ LeaveFrame();
   __ ret();
 }
 
 
 //  ECX: Inline cache data array.
 //  EDX: Arguments descriptor array.
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointDynamicStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(ECX);
   __ pushl(EDX);
   __ CallRuntime(kBreakpointDynamicHandlerRuntimeEntry);
   __ popl(EDX);
   __ popl(ECX);
   __ LeaveFrame();
 
   // Find out which dispatch stub to call.
   Label test_two, test_three, test_four;
   __ movl(EBX, FieldAddress(ECX, ICData::num_args_tested_offset()));
@@ skipping 248 matching lines @@
   __ Bind(&not_smi);
   __ LoadClassId(EAX, EAX);
   __ SmiTag(EAX);
   __ ret();
 
   __ Bind(&update_ic_data);
 
   // ECX: ICData
   __ movl(EAX, Address(ESP, 1 * kWordSize));
   __ movl(EDI, Address(ESP, 2 * kWordSize));
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(EDI);  // arg 0
   __ pushl(EAX);  // arg 1
   __ PushObject(Symbols::EqualOperator());  // Target's name.
   __ pushl(ECX);  // ICData
   __ CallRuntime(kUpdateICDataTwoArgsRuntimeEntry);
   __ Drop(4);
   __ LeaveFrame();
 
   __ jmp(&compute_result, Assembler::kNearJump);
 }
 
 
 // Calls to runtime to ooptimized give function
 // EDI: function to be reoptimized.
 // EDX: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  AssemblerMacros::EnterStubFrame(assembler);
+  __ EnterStubFrame();
   __ pushl(EDX);
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EDI);
   __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
   __ popl(EAX);  // Discard argument.
   __ popl(EAX);  // Get Code object
   __ popl(EDX);  // Restore argument descriptor.
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(EAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
@@ skipping 83 matching lines @@
   __ Bind(&done);
   __ popl(temp);
   __ popl(right);
   __ popl(left);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32