Runtime support for evaluation of static field initializer expressions

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 "vm/dart_entry.h"
@@ skipping 2437 matching lines @@
   __ movl(EDX, Immediate(num_context_variables()));
   StubCode* stub_code = compiler->isolate()->stub_code();
   const ExternalLabel label(stub_code->AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          RawPcDescriptors::kOther,
                          locs());
 }
 
 
+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;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(EAX));
   locs->set_out(0, Location::RegisterLocation(EAX));
   return locs;
 }
@@ skipping 332 matching lines @@
   if (op_kind() == Token::kSHL) {
     EmitSmiShiftLeft(compiler, this);
     return;
   }
 
   Register left = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   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()) {
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     const int32_t imm = reinterpret_cast<int32_t>(constant.raw());
     switch (op_kind()) {
     case Token::kADD:
         if (imm != 0) {
           // Checking overflow without emitting an instruction would be wrong.
@@ skipping 3707 matching lines @@
   __ movl(EDX, Immediate(kInvalidObjectPointer));
   __ movl(EDX, Immediate(kInvalidObjectPointer));
 #endif
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32