Initial support for polymorphic inlining.

runtime/vm/intermediate_language_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"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 1059 matching lines @@
   const Smi& smi_const = Smi::Cast(constant);
   const intptr_t scale = FlowGraphCompiler::ElementSizeFor(cid);
   const intptr_t data_offset = FlowGraphCompiler::DataOffsetFor(cid);
   const int64_t disp = smi_const.AsInt64Value() * scale + data_offset;
   return Utils::IsInt(32, disp);
 }
 
 
 LocationSummary* StringFromCharCodeInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
-  const intptr_t kNumTemps = 0;
-  LocationSummary* locs =
-      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   // TODO(fschneider): Allow immediate operands for the char code.
-  locs->set_in(0, Location::RequiresRegister());
-  locs->set_out(Location::RequiresRegister());
-  return locs;
+  return LocationSummary::Make(kNumInputs,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
 }
 
 
 void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register char_code = locs()->in(0).reg();
   Register result = locs()->out().reg();
   __ movl(result,
           Immediate(reinterpret_cast<uword>(Symbols::PredefinedAddress())));
   __ movl(result, Address(result,
                           char_code,
                           TIMES_HALF_WORD_SIZE,  // Char code is a smi.
                           Symbols::kNullCharCodeSymbolOffset * kWordSize));
 }
 
 
 LocationSummary* LoadUntaggedInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
-  const intptr_t kNumTemps = 0;
-  LocationSummary* locs =
-      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  locs->set_in(0, Location::RequiresRegister());
-  locs->set_out(Location::RequiresRegister());
-  return locs;
+  return LocationSummary::Make(kNumInputs,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
 }
 
 
 void LoadUntaggedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register object = locs()->in(0).reg();
   Register result = locs()->out().reg();
   __ movl(result, FieldAddress(object, offset()));
 }
 
 
+LocationSummary* LoadClassIdInstr::MakeLocationSummary() const {
+  const intptr_t kNumInputs = 1;
+  return LocationSummary::Make(kNumInputs,
+                               Location::RequiresRegister(),
+                               LocationSummary::kNoCall);
+}
+
+
+void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register object = locs()->in(0).reg();
+  Register result = locs()->out().reg();
+  Label load, done;
+  __ testl(object, Immediate(kSmiTagMask));

[srdjan, 2013/05/02 20:06:30]

We may be able to determine that object is never Smi (e.g., receiver of a class
that is outside the number chain). In that case we could generate better code.

+  __ j(NOT_ZERO, &load, Assembler::kNearJump);
+  __ movl(result, Immediate(Smi::RawValue(kSmiCid)));
+  __ jmp(&done);
+  __ Bind(&load);
+  __ LoadClassId(result, object);
+  __ SmiTag(result);
+  __ Bind(&done);
+}
+
+
 CompileType LoadIndexedInstr::ComputeType() const {
   switch (class_id_) {
     case kArrayCid:
     case kImmutableArrayCid:
       return CompileType::Dynamic();
 
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
       return CompileType::FromCid(kDoubleCid);
     case kTypedDataFloat32x4ArrayCid:
@@ skipping 2047 matching lines @@
 }
 
 
 void MathSqrtInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ sqrtsd(locs()->out().fpu_reg(), locs()->in(0).fpu_reg());
 }
 
 
 LocationSummary* UnarySmiOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
-  const intptr_t kNumTemps = 0;
-  LocationSummary* summary =
-      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  summary->set_in(0, Location::RequiresRegister());
-  summary->set_out(Location::SameAsFirstInput());
-  return summary;
+  return LocationSummary::Make(kNumInputs,
+                               Location::SameAsFirstInput(),
+                               LocationSummary::kNoCall);
 }
 
 
 void UnarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   ASSERT(value == locs()->out().reg());
   switch (op_kind()) {
     case Token::kNEGATE: {
       Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                             kDeoptUnaryOp);
@@ skipping 57 matching lines @@
   __ SmiTag(result);
   __ jmp(&done);
   __ Bind(&do_call);
   __ pushl(value_obj);
   ASSERT(instance_call()->HasICData());
   const ICData& ic_data = *instance_call()->ic_data();
   ASSERT((ic_data.NumberOfChecks() == 1));
   const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(0));
 
   const intptr_t kNumberOfArguments = 1;
-  compiler->GenerateStaticCall(instance_call()->deopt_id(),
+  compiler->GenerateStaticCall(deopt_id(),
                                instance_call()->token_pos(),
                                target,
                                kNumberOfArguments,
                                Array::Handle(),  // No argument names.,
                                locs());
   __ Bind(&done);
 }
 
 
 LocationSummary* DoubleToSmiInstr::MakeLocationSummary() const {
@@ skipping 75 matching lines @@
   __ leave();
 }
 
 
 LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
+  Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         kDeoptPolymorphicInstanceCallTestFail);
   if (ic_data().NumberOfChecks() == 0) {
     __ jmp(deopt);
     return;
   }
   ASSERT(ic_data().num_args_tested() == 1);
   if (!with_checks()) {
     ASSERT(ic_data().HasOneTarget());
     const Function& target = Function::ZoneHandle(ic_data().GetTargetAt(0));
-    compiler->GenerateStaticCall(instance_call()->deopt_id(),
+    compiler->GenerateStaticCall(deopt_id(),
                                  instance_call()->token_pos(),
                                  target,
                                  instance_call()->ArgumentCount(),
                                  instance_call()->argument_names(),
                                  locs());
     return;
   }
 
   // Load receiver into EAX.
   __ movl(EAX,
       Address(ESP, (instance_call()->ArgumentCount() - 1) * kWordSize));
 
   LoadValueCid(compiler, EDI, EAX,
                (ic_data().GetReceiverClassIdAt(0) == kSmiCid) ? NULL : deopt);
 
   compiler->EmitTestAndCall(ic_data(),
                             EDI,  // Class id register.
                             instance_call()->ArgumentCount(),
                             instance_call()->argument_names(),
                             deopt,
-                            instance_call()->deopt_id(),
+                            deopt_id(),
                             instance_call()->token_pos(),
                             locs());
 }
 
 
 LocationSummary* BranchInstr::MakeLocationSummary() const {
   UNREACHABLE();
   return NULL;
 }
 
@@ skipping 868 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32