Minimize differences between ia32 and x64 sources to facilitate maintenance.

runtime/vm/intermediate_language_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/intermediate_language.h"
 
 #include "lib/error.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 
 #define __ compiler->assembler()->
 
 namespace dart {
 
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, trace_functions);
 
+// Generic summary for call instructions that have all arguments pushed
+// on the stack and return the result in a fixed register RAX.
+LocationSummary* Computation::MakeCallSummary() {
+  LocationSummary* result = new LocationSummary(0, 0, LocationSummary::kCall);
+  result->set_out(Location::RegisterLocation(RAX));
+  return result;
+}
+
+
 void BindInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   computation()->EmitNativeCode(compiler);
   if (locs()->out().kind() == Location::kRegister) {
     // TODO(vegorov): this should really happen only for comparisons fused
     // with branches.  Currrently IR does not provide an easy way to remove
     // instructions from the graph so we just leave fused comparison in it
     // but change its result location to be NoLocation.
     compiler->frame_register_allocator()->Push(locs()->out().reg(), this);
   }
 }
@@ skipping 29 matching lines @@
       __ j(LESS_EQUAL, &not_yet_hot, Assembler::kNearJump);
       __ pushq(result);  // Preserve result.
       __ pushq(temp);  // Argument for runtime: function to optimize.
       __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry);
       __ popq(temp);  // Remove argument.
       __ popq(result);  // Restore result.
       __ Bind(&not_yet_hot);
     }
   }
   if (FLAG_trace_functions) {
-    __ pushq(result);  // Preserve result.
     const Function& function =
         Function::ZoneHandle(compiler->parsed_function().function().raw());
     __ LoadObject(temp, function);
+    __ pushq(result);  // Preserve result.
     __ pushq(temp);
     compiler->GenerateCallRuntime(AstNode::kNoId,
                                   0,
                                   CatchClauseNode::kInvalidTryIndex,
                                   kTraceFunctionExitRuntimeEntry);
     __ popq(temp);  // Remove argument.
     __ popq(result);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
 
   // Generate 8 bytes of NOPs so that the debugger can patch the
   // return pattern with a call to the debug stub.
+  // Note that the nop(8) byte pattern is not recognized by the debugger.
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
                                  cid(),
                                  token_index(),
                                  CatchClauseNode::kInvalidTryIndex);
 }
 
 
-// Generic summary for call instructions that have all arguments pushed
-// on the stack and return the result in a fixed register RAX.
-LocationSummary* Computation::MakeCallSummary() {
-  LocationSummary* result = new LocationSummary(0, 0, LocationSummary::kCall);
-  result->set_out(Location::RegisterLocation(RAX));
-  return result;
-}
-
-
 LocationSummary* ClosureCallComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* result = new LocationSummary(kNumInputs,
                                                 kNumTemps,
                                                 LocationSummary::kCall);
   result->set_out(Location::RegisterLocation(RAX));
   result->set_temp(0, Location::RegisterLocation(R10));  // Arg. descriptor.
   return result;
 }
@@ skipping 257 matching lines @@
   __ jmp(deopt);
   __ Bind(&done);
 }
 
 
 // First test if receiver is NULL, in which case === is applied.
 // If type feedback was provided (lists of <class-id, target>), do a
 // type by type check (either === or static call to the operator.
 static void EmitGenericEqualityCompare(FlowGraphCompiler* compiler,
                                        EqualityCompareComp* comp) {
-  const Immediate raw_null =
-        Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
+  const Immediate raw_null =
+      Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label done, non_null_compare;
   __ cmpq(left, raw_null);
   __ j(NOT_EQUAL, &non_null_compare, Assembler::kNearJump);
   // Comparison with NULL is "===".
   __ cmpq(left, right);
   if (comp->is_fused_with_branch()) {
     comp->fused_with_branch()->EmitBranchOnCondition(compiler, EQUAL);
   } else {
     Register result = comp->locs()->out().reg();
     Label load_true;
@@ skipping 137 matching lines @@
 
   if (comp->is_fused_with_branch()) {
     BranchInstr* branch = comp->fused_with_branch();
     BlockEntryInstr* nan_result = branch->is_negated() ?
         branch->true_successor() : branch->false_successor();
     __ j(PARITY_EVEN, compiler->GetBlockLabel(nan_result));
     branch->EmitBranchOnCondition(compiler, true_condition);
   } else {
     Register result = comp->locs()->out().reg();
     Label is_false, is_true, done;
-    __ j(PARITY_EVEN, &is_false, Assembler::kNearJump);
+    __ j(PARITY_EVEN, &is_false, Assembler::kNearJump);  // NaN -> false;
     __ j(true_condition, &is_true, Assembler::kNearJump);
     __ Bind(&is_false);
     __ LoadObject(result, compiler->bool_false());
     __ jmp(&done);
     __ Bind(&is_true);
     __ LoadObject(result, compiler->bool_true());
     __ Bind(&done);
   }
 }
 
@@ skipping 72 matching lines @@
 LocationSummary* LoadIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (receiver_type() == kGrowableObjectArray) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
-  } else if (receiver_type() == kArray || receiver_type() == kImmutableArray) {
+  } else if ((receiver_type() == kArray) ||
+             (receiver_type() == kImmutableArray)) {
     return LocationSummary::Make(kNumInputs, Location::RequiresRegister());
   } else {
     ASSERT(receiver_type() == kIllegalObjectKind);
     return MakeCallSummary();
   }
 }
 
 
 static void EmitLoadIndexedPolymorphic(FlowGraphCompiler* compiler,
                                         LoadIndexedComp* comp) {
@@ skipping 22 matching lines @@
                             kNumArguments,
                             Array::Handle(),  // No named arguments.
                             deopt, &done,  // Labels.
                             comp->cid(),
                             comp->token_index(),
                             comp->try_index());
   __ Bind(&done);
 }
 
 
-
 void LoadIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (receiver_type() == kIllegalObjectKind) {
     if (HasICData()) {
       EmitLoadIndexedPolymorphic(compiler, this);
     } else {
       compiler->EmitLoadIndexedGeneric(this);
     }
     ASSERT(locs()->out().reg() == RAX);
     return;
   }
@@ skipping 63 matching lines @@
     return locs;
   } else if (receiver_type() == kArray) {
     return LocationSummary::Make(kNumInputs, Location::NoLocation());
   } else {
     ASSERT(receiver_type() == kIllegalObjectKind);
     return MakeCallSummary();
   }
 }
 
 
-
 static void EmitStoreIndexedGeneric(FlowGraphCompiler* compiler,
                                     StoreIndexedComp* comp) {
   const String& function_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
 
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                  comp->cid(),
                                  comp->token_index(),
                                  comp->try_index());
 
   const intptr_t kNumArguments = 3;
   const intptr_t kNumArgsChecked = 1;  // Type-feedback.
   compiler->GenerateInstanceCall(comp->cid(),
                                  comp->token_index(),
                                  comp->try_index(),
                                  function_name,
                                  kNumArguments,
-                                 Array::ZoneHandle(),  // No names arguments.
+                                 Array::ZoneHandle(),  // No named arguments.
                                  kNumArgsChecked);
 }
 
 
 static void EmitStoreIndexedPolymorphic(FlowGraphCompiler* compiler,
                                         StoreIndexedComp* comp) {
   Label* deopt = compiler->AddDeoptStub(comp->cid(),
                                         comp->token_index(),
                                         comp->try_index(),
                                         kDeoptStoreIndexedPolymorphic);
@@ skipping 32 matching lines @@
     } else {
       EmitStoreIndexedGeneric(compiler, this);
     }
     return;
   }
 
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register value = locs()->in(2).reg();
 
-  const Class& receiver_class =
-      Class::ZoneHandle(Isolate::Current()->class_table()->At(
-          receiver_type()));
-
   Label* deopt = compiler->AddDeoptStub(cid(),
                                         token_index(),
                                         try_index(),
                                         kDeoptStoreIndexed,
                                         receiver,
                                         index,
                                         value);
 
   __ testq(receiver, Immediate(kSmiTagMask));  // Deoptimize if Smi.
   __ j(ZERO, deopt);
-  __ CompareClassId(receiver, receiver_class.id());
+  __ CompareClassId(receiver, receiver_type());
   __ j(NOT_EQUAL, deopt);
 
   __ testq(index, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 
   switch (receiver_type()) {
     case kArray:
     case kImmutableArray:
       __ cmpq(index, FieldAddress(receiver, Array::length_offset()));
       __ j(ABOVE_EQUAL, deopt);
@@ skipping 157 matching lines @@
   locs->set_temp(0, Location::RegisterLocation(R10));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void CreateArrayComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register temp_reg = locs()->temp(0).reg();
   Register result_reg = locs()->out().reg();
 
-  // 1. Allocate the array.  R10 = length, RBX = element type.
+  // Allocate the array.  R10 = length, RBX = element type.
   ASSERT(temp_reg == R10);
   ASSERT(locs()->in(0).reg() == RBX);
   __ movq(temp_reg, Immediate(Smi::RawValue(ElementCount())));
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &StubCode::AllocateArrayLabel(),
                          PcDescriptors::kOther);
   ASSERT(result_reg == RAX);
-  // 2. Initialize the array in result_reg with the element values.
+
+  // Pop the element values from the stack into the array.
   __ leaq(temp_reg, FieldAddress(result_reg, Array::data_offset()));
   for (int i = ElementCount() - 1; i >= 0; --i) {
     ASSERT(ElementAt(i)->IsUse());
     __ popq(Address(temp_reg, i * kWordSize));
   }
 }
 
 
-LocationSummary* AllocateObjectWithBoundsCheckComp::
-    MakeLocationSummary() const {
+LocationSummary*
+    AllocateObjectWithBoundsCheckComp::MakeLocationSummary() const {
   return LocationSummary::Make(2,
                                Location::RequiresRegister(),
                                LocationSummary::kCall);
 }
 
 
 void AllocateObjectWithBoundsCheckComp::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   const Class& cls = Class::ZoneHandle(constructor().owner());
   Register type_arguments = locs()->in(0).reg();
@@ skipping 68 matching lines @@
   Label type_arguments_instantiated;
   const intptr_t len = type_arguments().Length();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ cmpq(instantiator_reg, raw_null);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
   // Instantiate non-null type arguments.
   if (type_arguments().IsUninstantiatedIdentity()) {
-    Label type_arguments_uninstantiated;
     // Check if the instantiator type argument vector is a TypeArguments of a
     // matching length and, if so, use it as the instantiated type_arguments.
     // No need to check the instantiator ('instantiator_reg') for null here,
     // because a null instantiator will have the wrong class (Null instead of
     // TypeArguments).
+    Label type_arguments_uninstantiated;
     __ CompareClassId(instantiator_reg, kTypeArguments);
     __ j(NOT_EQUAL, &type_arguments_uninstantiated, Assembler::kNearJump);
     __ cmpq(FieldAddress(instantiator_reg, TypeArguments::length_offset()),
             Immediate(Smi::RawValue(len)));
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     __ Bind(&type_arguments_uninstantiated);
   }
   // A runtime call to instantiate the type arguments is required.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ PushObject(type_arguments());
   __ pushq(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kInstantiateTypeArgumentsRuntimeEntry);
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ popq(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
   // 'result_reg': Instantiated type arguments.
 }
 
 
-LocationSummary* ExtractConstructorTypeArgumentsComp::
-    MakeLocationSummary() const {
+LocationSummary*
+    ExtractConstructorTypeArgumentsComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
 void ExtractConstructorTypeArgumentsComp::EmitNativeCode(
@@ skipping 33 matching lines @@
   }
   // In the non-factory case, we rely on the allocation stub to
   // instantiate the type arguments.
   __ LoadObject(result_reg, type_arguments());
   // result_reg: uninstantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   // result_reg: uninstantiated or instantiated type arguments.
 }
 
 
-LocationSummary* ExtractConstructorInstantiatorComp::
-    MakeLocationSummary() const {
+LocationSummary*
+    ExtractConstructorInstantiatorComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
 void ExtractConstructorInstantiatorComp::EmitNativeCode(
@@ skipping 57 matching lines @@
                                               kNumTemps,
                                               LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(R10));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void AllocateContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == R10);
+  ASSERT(locs()->out().reg() == RAX);
 
   __ movq(R10, Immediate(num_context_variables()));
   const ExternalLabel label("alloc_context",
                             StubCode::AllocateContextEntryPoint());
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &label,
                          PcDescriptors::kOther);
 }
 
@@ skipping 105 matching lines @@
     return summary;
   } else if (op_kind() == Token::kSHR) {
     const intptr_t kNumTemps = 1;
     LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RegisterLocation(RCX));
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   } else if (op_kind() == Token::kSHL) {
+    // Two Smi operands can easily overflow into Mint.
     const intptr_t kNumTemps = 2;
-    LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
-    summary->set_in(0, Location::RequiresRegister());
+    LocationSummary* summary =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+    summary->set_in(0, Location::RegisterLocation(RAX));
     summary->set_in(1, Location::RequiresRegister());
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RequiresRegister());
     summary->set_temp(1, Location::RegisterLocation(RCX));
     return summary;
   } else {
     const intptr_t kNumTemps = 1;
     LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
 }
 
 
 static void EmitSmiBinaryOp(FlowGraphCompiler* compiler, BinaryOpComp* comp) {
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
   Register result = comp->locs()->out().reg();
   Register temp = comp->locs()->temp(0).reg();
   ASSERT(left == result);
   Label* deopt = compiler->AddDeoptStub(comp->instance_call()->cid(),
                                         comp->instance_call()->token_index(),
                                         comp->instance_call()->try_index(),
                                         kDeoptSmiBinaryOp,
                                         temp,
                                         right);
+  // TODO(vegorov): for many binary operations this pattern can be rearranged
+  // to save one move.
   __ movq(temp, left);
   __ orq(left, right);
   __ testq(left, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
   __ movq(left, temp);
   switch (comp->op_kind()) {
     case Token::kADD: {
       __ addq(left, right);
       __ j(OVERFLOW, deopt);
       break;
@@ skipping 58 matching lines @@
       __ j(LESS, &count_ok, Assembler::kNearJump);
       __ movq(right, kCountLimit);
       __ Bind(&count_ok);
       ASSERT(right == RCX);  // Count must be in RCX
       __ SmiUntag(left);
       __ sarq(left, right);
       __ SmiTag(left);
       break;
     }
     case Token::kSHL: {
+      Label call_method, done;
       // Check if count too large for handling it inlined.
       __ cmpq(right,
           Immediate(reinterpret_cast<int64_t>(Smi::New(Smi::kBits))));
-      __ j(ABOVE_EQUAL, deopt);
+      __ j(ABOVE_EQUAL, &call_method, Assembler::kNearJump);
       Register right_temp = comp->locs()->temp(1).reg();
       ASSERT(right_temp == RCX);  // Count must be in RCX
       __ movq(right_temp, right);
       __ SmiUntag(right_temp);
       // Overflow test (preserve temp and right);
       __ shlq(left, right_temp);
       __ sarq(left, right_temp);
       __ cmpq(left, temp);
-      __ j(NOT_EQUAL, deopt);  // Overflow.
+      __ j(NOT_EQUAL, &call_method, Assembler::kNearJump);  // Overflow.
       // Shift for result now we know there is no overflow.
       __ shlq(left, right_temp);
+      __ jmp(&done);
+      {
+        __ Bind(&call_method);
+        Function& target = Function::ZoneHandle(
+            comp->ic_data()->GetTargetForReceiverClassId(kSmi));
+        ASSERT(!target.IsNull());
+        const intptr_t kArgumentCount = 2;
+        __ pushq(temp);
+        __ pushq(right);
+        compiler->GenerateStaticCall(comp->instance_call()->cid(),
+                                     comp->instance_call()->token_index(),
+                                     comp->instance_call()->try_index(),
+                                     target,
+                                     kArgumentCount,
+                                     Array::Handle());  // No argument names.
+        ASSERT(result == RAX);
+      }
+      __ Bind(&done);
       break;
     }
     case Token::kDIV: {
       // Dispatches to 'Double./'.
       // TODO(srdjan): Implement as conversion to double and double division.
       UNREACHABLE();
       break;
     }
     case Token::kMOD: {
       // TODO(srdjan): Implement.
@@ skipping 280 matching lines @@
 LocationSummary* ToDoubleComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   if (from() == kDouble) {
     const intptr_t kNumTemps = 0;
     LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_out(Location::SameAsFirstInput());
     return locs;
   } else {
     ASSERT(from() == kSmi);
-    return MakeCallSummary();
+    return MakeCallSummary();  // Calls a stub to allocate result.
   }
 }
 
 
 void ToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = (from() == kDouble) ? locs()->in(0).reg() : RBX;
   Register result = locs()->out().reg();
 
   const DeoptReasonId deopt_reason = (from() == kDouble) ?
       kDeoptDoubleToDouble : kDeoptIntegerToDouble;
@@ skipping 12 matching lines @@
     return;
   }
 
   ASSERT(from() == kSmi);
 
   const Class& double_class = compiler->double_class();
   const Code& stub =
     Code::Handle(StubCode::GetAllocationStubForClass(double_class));
   const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
 
-  // TODO(vegorov): allocate box in the driver loop to avoid pushing and poping.
+  // TODO(vegorov): allocate box in the driver loop to avoid spilling.
   compiler->GenerateCall(instance_call()->token_index(),
                          instance_call()->try_index(),
                          &label,
                          PcDescriptors::kOther);
   ASSERT(result == RAX);
   __ popq(value);
 
   __ testq(value, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);  // Deoptimize if not Smi.
   __ SmiUntag(value);
@@ skipping 15 matching lines @@
                                         kDeoptPolymorphicInstanceCallTestFail);
   if (!HasICData() || (ic_data()->NumberOfChecks() == 0)) {
     __ jmp(deopt);
     return;
   }
   ASSERT(HasICData());
   ASSERT(ic_data()->num_args_tested() == 1);
   Label handle_smi;
   Label* is_smi_label =
       ic_data()->GetReceiverClassIdAt(0) == kSmi ?  &handle_smi : deopt;
+
   // Load receiver into RAX.
   __ movq(RAX,
       Address(RSP, (instance_call()->ArgumentCount() - 1) * kWordSize));
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(ZERO, is_smi_label);
   Label done;
   __ LoadClassId(RDI, RAX);
   compiler->EmitTestAndCall(*ic_data(),
                             RDI,  // Class id register.
                             instance_call()->ArgumentCount(),
@@ skipping 14 matching lines @@
                                  instance_call()->argument_names());
   }
   __ Bind(&done);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64