Runtime support for evaluation of static field initializer expressions

runtime/vm/intermediate_language_ia32.cc

Index: runtime/vm/intermediate_language_ia32.cc
===================================================================
--- runtime/vm/intermediate_language_ia32.cc	(revision 39260)
+++ runtime/vm/intermediate_language_ia32.cc	(working copy)
@@ -2455,6 +2455,49 @@
 }
 
 
+LocationSummary* InitStaticFieldInstr::MakeLocationSummary(Isolate* isolate,

[Florian Schneider, 2014/08/15 09:56:35]

I don't think we need a new instruction (and AST node) for this. It adds a lot
of platform-specific code duplication with no benefit.

Instead I'd just create the control flow AST in the parser:

temp = field.value;
if (temp === sentinel || temp === transition_sentinel) {
  call runtime
}

I think a generic CallRuntime instruction would be useful, since we already have
a couple of instructions that do exactly that.

[hausner, 2014/08/15 23:00:46]

On 2014/08/15 09:56:35, Florian Schneider wrote:

As Srdjan responded off-line, the optimizer can only eliminate the dead code for
const and final fields. We'd have to add special handling of comparison to
sentinel() and transition_sentinel() to handle non-final fields.

I agree that a solution with less platform-dependent code would be nicer, but it
would complicate unrelated instructions. The AST node and CallRuntimeInstruction
would still be necessary even if the guards were expressed in AST nodes and
corresponding backend nodes.

+                                                           bool opt) const {
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 1;
+  LocationSummary* locs = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
+  locs->set_in(0, Location::RegisterLocation(EAX));
+  locs->set_out(0, Location::RegisterLocation(EAX));
+  locs->set_temp(0, Location::RegisterLocation(ECX));
+  return locs;
+}
+
+
+void InitStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register field = locs()->in(0).reg();
+  Register result = locs()->out(0).reg();
+  Register temp = locs()->temp(0).reg();
+
+  Label call_runtime, no_call;
+
+  __ movl(temp, FieldAddress(field, Field::value_offset()));
+  __ CompareObject(temp, Object::sentinel());
+  __ j(EQUAL, &call_runtime);
+
+  __ CompareObject(temp, Object::transition_sentinel());
+  __ j(NOT_EQUAL, &no_call);
+
+  __ Bind(&call_runtime);
+  __ PushObject(Object::null_object());  // Make room for (unused) result.
+  __ pushl(field);
+  compiler->GenerateRuntimeCall(token_pos(),
+                                deopt_id(),
+                                kInitStaticFieldRuntimeEntry,
+                                1,
+                                locs());
+  __ popl(result);  // Remove argument.
+  __ popl(result);  // Remove result.
+
+  __ Bind(&no_call);
+}
+
+
+
 LocationSummary* CloneContextInstr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
   const intptr_t kNumInputs = 1;
@@ -2807,7 +2850,7 @@
   ASSERT(left == result);
   Label* deopt = NULL;
   if (CanDeoptimize()) {
-    deopt  = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinarySmiOp);
+    deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinarySmiOp);
   }
 
   if (locs()->in(1).IsConstant()) {