VM precompiler: Allow optimizing static initializers.

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 752 matching lines @@
         if (FLAG_trace_precompiler) {
           THR_Print("Precompiling initializer for %s\n", field.ToCString());
         }
         ASSERT(Dart::snapshot_kind() != Snapshot::kAppNoJIT);
         field.SetStaticValue(Instance::Handle(field.SavedInitialStaticValue()));
         const Function& initializer =
             Function::Handle(CompileStaticInitializer(field));
         if (!initializer.IsNull()) {
           field.SetPrecompiledInitializer(initializer);
         }
+        ASSERT(field.HasPrecompiledInitializer());
+        const Function& function =
+            Function::Handle(Z, field.PrecompiledInitializer());
+        AddCalleesOf(function);
       }
-
-      const Function& function =
-          Function::Handle(Z, field.PrecompiledInitializer());
-      AddCalleesOf(function);
     }
   }
 }
 
 
 RawFunction* Precompiler::CompileStaticInitializer(const Field& field) {
   ASSERT(field.is_static());
-  if (field.HasPrecompiledInitializer()) {
-    // TODO(rmacnak): Investigate why this happens for _enum_names.
-    THR_Print("Warning: Ignoring repeated request for initializer for %s\n",
-              field.ToCString());
-    return Function::null();
-  }
+  ASSERT(!field.HasPrecompiledInitializer());
   Thread* thread = Thread::Current();
   StackZone zone(thread);
 
   ParsedFunction* parsed_function = Parser::ParseStaticFieldInitializer(field);
 
   parsed_function->AllocateVariables();
-  // Non-optimized code generator.
   DartCompilationPipeline pipeline;
   PrecompileParsedFunctionHelper helper(parsed_function,
-                                        /* optimized = */ false);
-  helper.Compile(&pipeline);
+                                        /* optimized = */ true);
+  bool success = helper.Compile(&pipeline);
+  ASSERT(success);
+
+  if ((FLAG_disassemble || FLAG_disassemble_optimized) &&
+      FlowGraphPrinter::ShouldPrint(parsed_function->function())) {
+    Disassembler::DisassembleCode(parsed_function->function(),
+                                  /* optimized = */ true);
+  }
   return parsed_function->function().raw();
 }
 
 
 RawObject* Precompiler::EvaluateStaticInitializer(const Field& field) {
   ASSERT(field.is_static());
   // The VM sets the field's value to transiton_sentinel prior to
   // evaluating the initializer value.
   ASSERT(field.StaticValue() == Object::transition_sentinel().raw());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Under precompilation, the initializer may have already been compiled, in
     // which case use it. Under lazy compilation or early in precompilation, the
     // initializer has not yet been created, so create it now, but don't bother
     // remembering it because it won't be used again.
     Function& initializer = Function::Handle();
     if (!field.HasPrecompiledInitializer()) {
       initializer = CompileStaticInitializer(field);
-      Code::Handle(initializer.unoptimized_code()).set_var_descriptors(
-          Object::empty_var_descriptors());
     } else {
       initializer ^= field.PrecompiledInitializer();
     }
     // Invoke the function to evaluate the expression.
     return DartEntry::InvokeFunction(initializer, Object::empty_array());
   } else {
     Thread* const thread = Thread::Current();
     StackZone zone(thread);
     const Error& error =
         Error::Handle(thread->zone(), thread->sticky_error());
@@ skipping 1120 matching lines @@
   };
 
   DedupInstructionsVisitor visitor(Z);
   VisitFunctions(&visitor);
 }
 
 void Precompiler::VisitFunctions(FunctionVisitor* visitor) {
   Library& lib = Library::Handle(Z);
   Class& cls = Class::Handle(Z);
   Array& functions = Array::Handle(Z);
+  Array& fields = Array::Handle(Z);
+  Field& field = Field::Handle(Z);
   Object& object = Object::Handle(Z);
   Function& function = Function::Handle(Z);
   GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
 
   for (intptr_t i = 0; i < libraries_.Length(); i++) {
     lib ^= libraries_.At(i);
     ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
     while (it.HasNext()) {
       cls = it.GetNextClass();
       if (cls.IsDynamicClass()) {
@@ skipping 11 matching lines @@
       }
 
       functions = cls.invocation_dispatcher_cache();
       for (intptr_t j = 0; j < functions.Length(); j++) {
         object = functions.At(j);
         if (object.IsFunction()) {
           function ^= functions.At(j);
           visitor->VisitFunction(function);
         }
       }
+      fields = cls.fields();
+      for (intptr_t j = 0; j < fields.Length(); j++) {
+        field ^= fields.At(j);
+        if (field.is_static() && field.HasPrecompiledInitializer()) {
+          function ^= field.PrecompiledInitializer();
+          visitor->VisitFunction(function);
+        }
+      }
     }
   }
   closures = isolate()->object_store()->closure_functions();
   for (intptr_t j = 0; j < closures.Length(); j++) {
     function ^= closures.At(j);
     visitor->VisitFunction(function);
     ASSERT(!function.HasImplicitClosureFunction());
   }
 }
 
@@ skipping 120 matching lines @@
 }
 
 
 // Return false if bailed out.
 // If optimized_result_code is not NULL then it is caller's responsibility
 // to install code.
 bool PrecompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
   ASSERT(FLAG_precompiled_mode);
   const Function& function = parsed_function()->function();
   if (optimized() && !function.IsOptimizable()) {
+    // All functions compiled by precompiler must be optimizable.
+    UNREACHABLE();
     return false;
   }
   bool is_compiled = false;
   Zone* const zone = thread()->zone();
 #ifndef PRODUCT
   TimelineStream* compiler_timeline = Timeline::GetCompilerStream();
 #endif  // !PRODUCT
   CSTAT_TIMER_SCOPE(thread(), codegen_timer);
   HANDLESCOPE(thread());
 
@@ skipping 555 matching lines @@
       // We got an error during compilation.
       error = thread->sticky_error();
       thread->clear_sticky_error();
       ASSERT(error.IsLanguageError() &&
              LanguageError::Cast(error).kind() != Report::kBailout);
       return error.raw();
     }
 
     per_compile_timer.Stop();
 
-    if (trace_compiler && success) {
+    if (trace_compiler) {
       THR_Print("--> '%s' entry: %#" Px " size: %" Pd " time: %" Pd64 " us\n",
                 function.ToFullyQualifiedCString(),
                 Code::Handle(function.CurrentCode()).EntryPoint(),
                 Code::Handle(function.CurrentCode()).Size(),
                 per_compile_timer.TotalElapsedTime());
     }
 
     if (FLAG_disassemble && FlowGraphPrinter::ShouldPrint(function)) {
       Disassembler::DisassembleCode(function, optimized);
     } else if (FLAG_disassemble_optimized &&
                optimized &&
                FlowGraphPrinter::ShouldPrint(function)) {
-      // TODO(fschneider): Print unoptimized code along with the optimized code.
-      THR_Print("*** BEGIN CODE\n");
       Disassembler::DisassembleCode(function, true);
-      THR_Print("*** END CODE\n");
     }
     return Error::null();
   } else {
     Thread* const thread = Thread::Current();
     StackZone stack_zone(thread);
     Error& error = Error::Handle();
     // We got an error during compilation.
     error = thread->sticky_error();
     thread->clear_sticky_error();
     // Precompilation may encounter compile-time errors.
@@ skipping 15 matching lines @@
       CompilationPipeline::New(thread->zone(), function);
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   return PrecompileFunctionHelper(pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart