Minimize differences between ia32 and x64 sources to facilitate maintenance.

runtime/vm/intermediate_language_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #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"

[srdjan, 2012/06/22 00:34:40]

Why do we need this include?

[regis, 2012/06/22 01:24:53]

Actually, I wonder why it was not needed in the first place. Removing it on the
x64 side results in a compilation error. I suspect that the x64 compiler is
doing more aggressive inlining and the structure of ParsedFunction is needed.
The include does not hurt here. 

 #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
@@ skipping 61 matching lines @@
     __ pushl(temp);
     compiler->GenerateCallRuntime(AstNode::kNoId,
                                   0,
                                   CatchClauseNode::kInvalidTryIndex,
                                   kTraceFunctionExitRuntimeEntry);
     __ popl(temp);  // Remove argument.
     __ popl(result);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
-  // Add a NOP to make return code pattern 5 bytes long for patching
-  // in breakpoints during debugging.
+
+  // Generate 1 byte NOP so that the debugger can patch the
+  // return pattern with a call to the debug stub.
   __ nop(1);
   compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
                                  cid(),
                                  token_index(),
                                  CatchClauseNode::kInvalidTryIndex);
 }
 
 
 LocationSummary* ClosureCallComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
@@ skipping 330 matching lines @@
                                                    LocationSummary::kNoCall,
                                                    contains_branch);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
     if (!is_fused_with_branch()) {
       summary->set_out(Location::RequiresRegister());
     }
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
+  ASSERT(!is_fused_with_branch());
   ASSERT(operands_class_id() == kObject);
   return MakeCallSummary();
 }
 
 
 static Condition TokenKindToSmiCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kNE: return NOT_EQUAL;
     case Token::kLT: return LESS;
@@ skipping 24 matching lines @@
   __ j(NOT_ZERO, deopt);
 
   Condition true_condition = TokenKindToSmiCondition(comp->kind());
   __ cmpl(left, right);
 
   if (comp->is_fused_with_branch()) {
     comp->fused_with_branch()->EmitBranchOnCondition(compiler, true_condition);
   } else {
     Register result = comp->locs()->out().reg();
     Label done, is_true;
-
     __ j(true_condition, &is_true);
     __ LoadObject(result, compiler->bool_false());
     __ jmp(&done);
     __ Bind(&is_true);
     __ LoadObject(result, compiler->bool_true());
     __ Bind(&done);
   }
 }
 
 
@@ skipping 72 matching lines @@
                                  try_index(),
                                  function_name,
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No optional arguments.
                                  kNumArgsChecked);
   ASSERT(locs()->out().reg() == EAX);
 }
 
 
 LocationSummary* NativeCallComp::MakeLocationSummary() const {
-  LocationSummary* locs = new LocationSummary(0, 3, LocationSummary::kCall);
+  const intptr_t kNumInputs = 0;
+  const intptr_t kNumTemps = 3;
+  LocationSummary* locs = new LocationSummary(kNumInputs,
+                                              kNumTemps,
+                                              LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(EAX));
   locs->set_temp(1, Location::RegisterLocation(ECX));
   locs->set_temp(2, Location::RegisterLocation(EDX));
   locs->set_out(Location::RequiresRegister());
   return locs;
 }
 
 
 void NativeCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == EAX);
   ASSERT(locs()->temp(1).reg() == ECX);
   ASSERT(locs()->temp(2).reg() == EDX);
   Register result = locs()->out().reg();
+
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   // Pass a pointer to the first argument in EAX.
   intptr_t arg_count = argument_count();
   if (is_native_instance_closure()) {
     arg_count += 1;
   }
   if (!has_optional_parameters() && !is_native_instance_closure()) {
     __ leal(EAX, Address(EBP, (1 + arg_count) * kWordSize));
   } else {
@@ skipping 66 matching lines @@
 void LoadIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (receiver_type() == kIllegalObjectKind) {
     if (HasICData()) {
       EmitLoadIndexedPolymorphic(compiler, this);
     } else {
       compiler->EmitLoadIndexedGeneric(this);
     }
     ASSERT(locs()->out().reg() == EAX);
     return;
   }
+
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register result = locs()->out().reg();
   Register temp = locs()->temp(0).reg();
 
-  const Class& receiver_class =
-      Class::ZoneHandle(Isolate::Current()->class_table()->At(
-          receiver_type()));
-
   const DeoptReasonId deopt_reason = (receiver_type() == kGrowableObjectArray) ?
       kDeoptLoadIndexedGrowableArray : kDeoptLoadIndexedFixedArray;
 
   Label* deopt = compiler->AddDeoptStub(cid(),
                                         token_index(),
                                         try_index(),
                                         deopt_reason,
                                         receiver,
                                         index);
 
   __ testl(receiver, Immediate(kSmiTagMask));  // Deoptimize if Smi.
   __ j(ZERO, deopt);
-  __ CompareClassId(receiver, receiver_class.id(), temp);
+  __ CompareClassId(receiver, receiver_type(), temp);
   __ j(NOT_EQUAL, deopt);
 
   __ testl(index, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 
   switch (receiver_type()) {
     case kArray:
     case kImmutableArray:
       __ cmpl(index, FieldAddress(receiver, Array::length_offset()));
       __ j(ABOVE_EQUAL, deopt);
@@ skipping 17 matching lines @@
 
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 LocationSummary* StoreIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
-  if (receiver_type() == kGrowableObjectArray || receiver_type() == kArray) {
+  if ((receiver_type() == kGrowableObjectArray) ||
+      (receiver_type() == kArray)) {
     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_in(2, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::NoLocation());
     return locs;
   } else {
     ASSERT(receiver_type() == kIllegalObjectKind);
@@ skipping 12 matching lines @@
                                  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 named args.
+                                 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 219 matching lines @@
   locs->set_in(0, Location::RegisterLocation(ECX));
   locs->set_temp(0, Location::RegisterLocation(EDX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 void CreateArrayComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register temp_reg = locs()->temp(0).reg();
   Register result_reg = locs()->out().reg();
+
+  // Allocate the array.  EDX = length, ECX = element type.
   ASSERT(temp_reg == EDX);
   ASSERT(locs()->in(0).reg() == ECX);
-  // 1. Allocate the array.  EDX = length, ECX = element type.
-  __ movl(EDX,  Immediate(Smi::RawValue(ElementCount())));
+  __ movl(temp_reg,  Immediate(Smi::RawValue(ElementCount())));
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &StubCode::AllocateArrayLabel(),
                          PcDescriptors::kOther);
   ASSERT(result_reg == EAX);
+
   // Pop the element values from the stack into the array.
   __ leal(temp_reg, FieldAddress(result_reg, Array::data_offset()));
   for (int i = ElementCount() - 1; i >= 0; --i) {
     ASSERT(ElementAt(i)->IsUse());
     __ popl(Address(temp_reg, i * kWordSize));
   }
 }
 
 
 LocationSummary*
-AllocateObjectWithBoundsCheckComp::MakeLocationSummary() const {
+    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();
   Register instantiator_type_arguments = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
+  // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ pushl(Immediate(Smi::RawValue(token_index())));
   __ PushObject(cls);
   __ pushl(type_arguments);
   __ pushl(instantiator_type_arguments);
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kAllocateObjectWithBoundsCheckRuntimeEntry);
   // Pop instantiator type arguments, type arguments, class, and
@@ skipping 58 matching lines @@
   if (type_arguments().IsRawInstantiatedRaw(len)) {
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ cmpl(instantiator_reg, raw_null);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
   // Instantiate non-null type arguments.
   if (type_arguments().IsUninstantiatedIdentity()) {
     // 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 instantiator for null (again), because a null instance
-    // will have the wrong class (Null instead of TypeArguments).
+    // 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, temp);
     __ j(NOT_EQUAL, &type_arguments_uninstantiated, Assembler::kNearJump);
     __ cmpl(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());
   __ pushl(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kInstantiateTypeArgumentsRuntimeEntry);
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ popl(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
+  // 'result_reg': Instantiated type arguments.
 }
 
 
 LocationSummary*
-ExtractConstructorTypeArgumentsComp::MakeLocationSummary() const {
+    ExtractConstructorTypeArgumentsComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
@@ skipping 36 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 {
+    ExtractConstructorInstantiatorComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
@@ skipping 591 matching lines @@
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
   ASSERT(value == result);
   Label* deopt = compiler->AddDeoptStub(instance_call()->cid(),
                                         instance_call()->token_index(),
                                         instance_call()->try_index(),
                                         kDeoptUnaryOp,
                                         value);
   if (test_class_id == kDouble) {
     Register temp = locs()->temp(0).reg();
-    ASSERT(result != temp);
     __ testl(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);  // Smi.
     __ CompareClassId(value, kDouble, temp);
     __ j(NOT_EQUAL, deopt);
     // Allocate result object.
     const Class& double_class = compiler->double_class();
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(double_class));
     const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
     __ pushl(value);
     compiler->GenerateCall(instance_call()->token_index(),
                            instance_call()->try_index(),
                            &label,
                            PcDescriptors::kOther);
     // Result is in EAX.
+    ASSERT(result != temp);
     __ movl(result, EAX);
     __ popl(temp);
     __ movsd(XMM0, FieldAddress(temp, Double::value_offset()));
     __ DoubleNegate(XMM0);
     __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
   } else {
     UNREACHABLE();
   }
 }
 
 
 LocationSummary* ToDoubleComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   if (from() == kDouble) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::SameAsFirstInput());
     locs->set_temp(0, Location::RequiresRegister());
     return locs;
   } else {
     ASSERT(from() == kSmi);
     return MakeCallSummary();  // Calls a stub to allocate result.
   }
 }
 
 
 void ToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register value = (from() == kDouble) ? locs()->in(0).reg() : EBX;
   Register result = locs()->out().reg();
-  Register value = (from() == kDouble) ? locs()->in(0).reg() : EBX;
 
   const DeoptReasonId deopt_reason = (from() == kDouble) ?
       kDeoptDoubleToDouble : kDeoptIntegerToDouble;
   Label* deopt = compiler->AddDeoptStub(instance_call()->cid(),
                                         instance_call()->token_index(),
                                         instance_call()->try_index(),
                                         deopt_reason,
                                         value);
 
   if (from() == kDouble) {
@@ skipping 77 matching lines @@
                                  instance_call()->argument_names());
   }
   __ Bind(&done);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64