VM: Small generated code size improvements on x64.

runtime/vm/flow_graph_compiler_x64.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"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 1231 matching lines @@
   StubCode* stub_code = isolate()->stub_code();
   const uword label_address =
       stub_code->UnoptimizedStaticCallEntryPoint(ic_data.NumArgsTested());
   ExternalLabel target_label(label_address);
   __ LoadObject(RBX, ic_data, PP);
   GenerateDartCall(deopt_id,
                    token_pos,
                    &target_label,
                    RawPcDescriptors::kUnoptStaticCall,
                    locs);
-  __ Drop(argument_count);
+  __ Drop(argument_count, RCX);

[zra, 2015/01/08 15:50:09]

A comment here (and below for other situations) about why TMP can't be used
would be useful. Also, it seems like this is a bug-fix. Is there a test that
fails?

[Florian Schneider, 2015/01/08 16:15:30]

No bug fix, but TMP requires a REX prefix. Using RCX saves 1 byte.

 #if defined(DEBUG)
   __ movq(RBX, Immediate(kInvalidObjectPointer));
   __ movq(R10, Immediate(kInvalidObjectPointer));
 #endif
 }
 
 
 void FlowGraphCompiler::EmitEdgeCounter() {
   // We do not check for overflow when incrementing the edge counter.  The
   // function should normally be optimized long before the counter can
@@ skipping 41 matching lines @@
   // top-level function (parsed_function().function()) which could be
   // reoptimized and which counter needs to be incremented.
   // Pass the function explicitly, it is used in IC stub.
   __ LoadObject(RDI, parsed_function().function(), PP);
   __ LoadObject(RBX, ic_data, PP);
   GenerateDartCall(deopt_id,
                    token_pos,
                    target_label,
                    RawPcDescriptors::kIcCall,
                    locs);
-  __ Drop(argument_count);
+  __ Drop(argument_count, RCX);
 }
 
 
 void FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
                                          const ICData& ic_data,
                                          intptr_t argument_count,
                                          intptr_t deopt_id,
                                          intptr_t token_pos,
                                          LocationSummary* locs) {
   ASSERT(Array::Handle(ic_data.arguments_descriptor()).Length() > 0);
   __ LoadObject(RBX, ic_data, PP);
   GenerateDartCall(deopt_id,
                    token_pos,
                    target_label,
                    RawPcDescriptors::kIcCall,
                    locs);
-  __ Drop(argument_count);
+  __ Drop(argument_count, RCX);
 #if defined(DEBUG)
   __ movq(R10, Immediate(kInvalidObjectPointer));
 #endif
 }
 
 
 void FlowGraphCompiler::EmitMegamorphicInstanceCall(
     const ICData& ic_data,
     intptr_t argument_count,
     intptr_t deopt_id,
@@ skipping 43 matching lines @@
   __ movq(RCX, FieldAddress(RAX, Function::instructions_offset()));
   __ LoadObject(RBX, ic_data, PP);
   __ LoadObject(R10, arguments_descriptor, PP);
   __ AddImmediate(
       RCX, Immediate(Instructions::HeaderSize() - kHeapObjectTag), PP);
   __ call(RCX);
   AddCurrentDescriptor(RawPcDescriptors::kOther,
       Isolate::kNoDeoptId, token_pos);
   RecordSafepoint(locs);
   AddDeoptIndexAtCall(Isolate::ToDeoptAfter(deopt_id), token_pos);
-  __ Drop(argument_count);
+  __ Drop(argument_count, RCX);
 }
 
 
 void FlowGraphCompiler::EmitOptimizedStaticCall(
     const Function& function,
     const Array& arguments_descriptor,
     intptr_t argument_count,
     intptr_t deopt_id,
     intptr_t token_pos,
     LocationSummary* locs) {
   StubCode* stub_code = isolate()->stub_code();
   __ LoadObject(R10, arguments_descriptor, PP);
   // Do not use the code from the function, but let the code be patched so that
   // we can record the outgoing edges to other code.
   GenerateDartCall(deopt_id,
                    token_pos,
                    &stub_code->CallStaticFunctionLabel(),
                    RawPcDescriptors::kOptStaticCall,
                    locs);
   AddStaticCallTarget(function);
-  __ Drop(argument_count);
+  __ Drop(argument_count, RCX);
 }
 
 
 Condition FlowGraphCompiler::EmitEqualityRegConstCompare(
     Register reg,
     const Object& obj,
     bool needs_number_check,
     intptr_t token_pos) {
   ASSERT(!needs_number_check ||
          (!obj.IsMint() && !obj.IsDouble() && !obj.IsBigint()));
@@ skipping 131 matching lines @@
     }
     // Do not use the code from the function, but let the code be patched so
     // that we can record the outgoing edges to other code.
     GenerateDartCall(deopt_id,
                      token_index,
                      &stub_code->CallStaticFunctionLabel(),
                      RawPcDescriptors::kOptStaticCall,
                      locs);
     const Function& function = *sorted[i].target;
     AddStaticCallTarget(function);
-    __ Drop(argument_count);
+    __ Drop(argument_count, RCX);
     if (!is_last_check) {
       __ jmp(&match_found);
     }
     __ Bind(&next_test);
   }
   __ Bind(&match_found);
 }
 
 
 #undef __
@@ skipping 227 matching lines @@
   __ movups(reg, Address(RSP, 0));
   __ AddImmediate(RSP, Immediate(kFpuRegisterSize), PP);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64