VM: Compute static guarded cid for final instance fields.

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 60 matching lines @@
 DECLARE_FLAG(bool, verify_compiler);
 DECLARE_FLAG(bool, huge_method_cutoff_in_code_size);
 DECLARE_FLAG(bool, trace_failed_optimization_attempts);
 DECLARE_FLAG(bool, trace_inlining_intervals);
 DECLARE_FLAG(bool, trace_irregexp);
 
 #ifdef DART_PRECOMPILER
 
 class DartPrecompilationPipeline : public DartCompilationPipeline {
  public:
-  DartPrecompilationPipeline() : result_type_(CompileType::None()) { }
+  explicit DartPrecompilationPipeline(Zone* zone,
+                                      FieldTypeMap* field_map = NULL)
+      : zone_(zone),
+        result_type_(CompileType::None()),
+        field_map_(field_map) { }
 
   virtual void FinalizeCompilation(FlowGraph* flow_graph) {
+    if ((field_map_ != NULL )&&
+        flow_graph->function().IsGenerativeConstructor()) {
+      for (BlockIterator block_it = flow_graph->reverse_postorder_iterator();
+           !block_it.Done();
+           block_it.Advance()) {
+        ForwardInstructionIterator it(block_it.Current());
+        for (; !it.Done(); it.Advance()) {
+          StoreInstanceFieldInstr* store = it.Current()->AsStoreInstanceField();
+          if (store != NULL) {
+            if (!store->field().IsNull() && store->field().is_final()) {
+              if (FLAG_trace_precompiler) {
+                THR_Print("Found store to %s <- %s\n",
+                          store->field().ToCString(),
+                          store->value()->Type()->ToCString());
+              }
+              FieldTypePair* entry = field_map_->Lookup(&store->field());
+              if (entry == NULL) {
+                field_map_->Insert(FieldTypePair(
+                    &Field::Handle(zone_, store->field().raw()),  // Re-wrap.
+                    store->value()->Type()->ToCid()));
+                if (FLAG_trace_precompiler) {
+                    THR_Print(" initial type = %s\n",
+                              store->value()->Type()->ToCString());
+                }
+                continue;
+              }
+              CompileType type = CompileType::FromCid(entry->cid_);
+              if (FLAG_trace_precompiler) {
+                  THR_Print(" old type = %s\n", type.ToCString());
+              }
+              type.Union(store->value()->Type());
+              if (FLAG_trace_precompiler) {
+                  THR_Print(" new type = %s\n", type.ToCString());
+              }
+              entry->cid_ = type.ToCid();
+            }
+          }
+        }
+      }
+    }
+
     CompileType result_type = CompileType::None();
     for (BlockIterator block_it = flow_graph->reverse_postorder_iterator();
          !block_it.Done();
          block_it.Advance()) {
       ForwardInstructionIterator it(block_it.Current());
       for (; !it.Done(); it.Advance()) {
         ReturnInstr* return_instr = it.Current()->AsReturn();
         if (return_instr != NULL) {
           result_type.Union(return_instr->InputAt(0)->Type());
         }
       }
     }
     result_type_ = result_type;
   }
 
   CompileType result_type() { return result_type_; }
 
  private:
+  Zone* zone_;
   CompileType result_type_;
+  FieldTypeMap* field_map_;
 };
 
 
 class PrecompileParsedFunctionHelper : public ValueObject {
  public:
   PrecompileParsedFunctionHelper(ParsedFunction* parsed_function,
                                  bool optimized)
       : parsed_function_(parsed_function),
         optimized_(optimized),
         thread_(Thread::Current()) {
@@ skipping 60 matching lines @@
     pending_functions_(
         GrowableObjectArray::Handle(GrowableObjectArray::New())),
     sent_selectors_(),
     enqueued_functions_(),
     fields_to_retain_(),
     functions_to_retain_(),
     classes_to_retain_(),
     typeargs_to_retain_(),
     types_to_retain_(),
     consts_to_retain_(),
+    field_type_map_(),
     error_(Error::Handle()) {
 }
 
 
 void Precompiler::DoCompileAll(
     Dart_QualifiedFunctionName embedder_entry_points[]) {
   ASSERT(I->compilation_allowed());
 
   {
     StackZone stack_zone(T);
     zone_ = stack_zone.GetZone();
 
     { HANDLESCOPE(T);
       // Make sure class hierarchy is stable before compilation so that CHA
       // can be used. Also ensures lookup of entry points won't miss functions
       // because their class hasn't been finalized yet.
       FinalizeAllClasses();
 
       SortClasses();
 
       // Precompile static initializers to compute result type information.
       PrecompileStaticInitializers();
 
+      // Precompile constructors to compute type information for final fields.
+      ClearAllCode();
+      PrecompileConstructors();
+
       for (intptr_t round = 0; round < FLAG_precompiler_rounds; round++) {
         if (FLAG_trace_precompiler) {
           THR_Print("Precompiler round %" Pd "\n", round);
         }
 
         if (round > 0) {
           ResetPrecompilerState();
         }
 
         // TODO(rmacnak): We should be able to do a more thorough job and drop
@@ skipping 116 matching lines @@
     Field& field_;
     Function& function_;
   };
 
   HANDLESCOPE(T);
   StaticInitializerVisitor visitor(Z);
   VisitClasses(&visitor);
 }
 
 
+void Precompiler::PrecompileConstructors() {
+  class ConstructorVisitor : public FunctionVisitor {
+   public:
+    explicit ConstructorVisitor(Zone* zone, FieldTypeMap* map)
+        : zone_(zone), field_type_map_(map) {
+      ASSERT(map != NULL);
+    }
+    void Visit(const Function& function) {
+      if (!function.IsGenerativeConstructor()) return;
+      if (function.HasCode()) return;

[rmacnak, 2016/09/06 20:38:41]

This should only happen for const constructors right?  Maybe the code should be
cleared here and the constructor recompiled so if in

class A {
  final b = const B()
}

class B {
  final x = 'string';
  const B()
}

if we visit A before B and compile B's constructor as a side effect, we still
discover that B.x is OneByteString.

[Florian Schneider, 2016/09/06 21:00:31]

Done. Yes, it happens for const-constructors.

+      if (FLAG_trace_precompiler) {
+        THR_Print("Precompiling constructor %s\n", function.ToCString());
+      }
+      CompileFunction(Thread::Current(),
+                      zone_,
+                      function,
+                      field_type_map_);
+    }
+   private:
+    Zone* zone_;
+    FieldTypeMap* field_type_map_;
+  };
+
+  HANDLESCOPE(T);
+  ConstructorVisitor visitor(zone_, &field_type_map_);
+  VisitFunctions(&visitor);
+
+  FieldTypeMap::Iterator it(field_type_map_.GetIterator());
+  for (FieldTypePair* current = it.Next();
+       current != NULL;
+       current = it.Next()) {
+    const intptr_t cid = current->cid_;
+    current->field_->set_guarded_cid(cid);
+    current->field_->set_is_nullable(cid == kNullCid || cid == kDynamicCid);
+    if (FLAG_trace_precompiler) {
+      THR_Print("Field %s <- Type %s\n", current->field_->ToCString(),
+          Class::Handle(T->isolate()->class_table()->At(cid)).ToCString());
+    }
+  }
+}
+
+
 void Precompiler::ClearAllCode() {
   class ClearCodeFunctionVisitor : public FunctionVisitor {
     void Visit(const Function& function) {
       function.ClearCode();
       function.ClearICDataArray();
     }
   };
   ClearCodeFunctionVisitor function_visitor;
   VisitFunctions(&function_visitor);
 
@@ skipping 250 matching lines @@
       THR_Print("Precompiling %" Pd " %s (%s, %s)\n",
                 function_count_,
                 function.ToLibNamePrefixedQualifiedCString(),
                 function.token_pos().ToCString(),
                 Function::KindToCString(function.kind()));
     }
 
     ASSERT(!function.is_abstract());
     ASSERT(!function.IsRedirectingFactory());
 
-    error_ = CompileFunction(thread_, function);
+    error_ = CompileFunction(thread_, zone_, function);
     if (!error_.IsNull()) {
       Jump(error_);
     }
     // Used in the JIT to save type-feedback across compilations.
     function.ClearICDataArray();
   } else {
     if (FLAG_trace_precompiler) {
       // This function was compiled from somewhere other than Precompiler,
       // such as const constructors compiled by the parser.
       THR_Print("Already has code: %s (%s, %s)\n",
@@ skipping 316 matching lines @@
 
 RawFunction* Precompiler::CompileStaticInitializer(const Field& field,
                                                    bool compute_type) {
   ASSERT(field.is_static());
   Thread* thread = Thread::Current();
   StackZone zone(thread);
 
   ParsedFunction* parsed_function = Parser::ParseStaticFieldInitializer(field);
 
   parsed_function->AllocateVariables();
-  DartPrecompilationPipeline pipeline;
+  DartPrecompilationPipeline pipeline(zone.GetZone());
   PrecompileParsedFunctionHelper helper(parsed_function,
                                         /* optimized = */ true);
   bool success = helper.Compile(&pipeline);
   ASSERT(success);
 
   if (compute_type && field.is_final()) {
     intptr_t result_cid = pipeline.result_type().ToCid();
     if (result_cid != kDynamicCid) {
       if (FLAG_trace_precompiler && FLAG_support_il_printer) {
         THR_Print("Setting guarded_cid of %s to %s\n", field.ToCString(),
@@ skipping 79 matching lines @@
     // would compile func automatically. We are checking fewer invariants
     // here.
     ParsedFunction* parsed_function = new ParsedFunction(thread, func);
     parsed_function->SetNodeSequence(fragment);
     fragment->scope()->AddVariable(parsed_function->EnsureExpressionTemp());
     fragment->scope()->AddVariable(
         parsed_function->current_context_var());
     parsed_function->AllocateVariables();
 
     // Non-optimized code generator.
-    DartPrecompilationPipeline pipeline;
+    DartPrecompilationPipeline pipeline(Thread::Current()->zone());
     PrecompileParsedFunctionHelper helper(parsed_function,
                                           /* optimized = */ false);
     helper.Compile(&pipeline);
     Code::Handle(func.unoptimized_code()).set_var_descriptors(
         Object::empty_var_descriptors());
 
     const Object& result = PassiveObject::Handle(
         DartEntry::InvokeFunction(func, Object::empty_array()));
     return result.raw();
   } else {
@@ skipping 2006 matching lines @@
     // Do not attempt to optimize functions that can cause errors.
     function.set_is_optimizable(false);
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
 RawError* Precompiler::CompileFunction(Thread* thread,
-                                       const Function& function) {
+                                       Zone* zone,
+                                       const Function& function,
+                                       FieldTypeMap* field_type_map) {
   VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
   TIMELINE_FUNCTION_COMPILATION_DURATION(thread, "CompileFunction", function);
 
-  CompilationPipeline* pipeline =
-      CompilationPipeline::New(thread->zone(), function);
-
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
-  return PrecompileFunctionHelper(pipeline, function, optimized);
+  DartPrecompilationPipeline pipeline(zone, field_type_map);
+  return PrecompileFunctionHelper(&pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart