[kernel] vm: Fix a few issues in the kernel flow graph builder, update status file for checked-mode

runtime/vm/compiler.cc

 // Copyright (c) 2012, 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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 1674 matching lines @@
   // evaluating the initializer value.
   ASSERT(field.StaticValue() == Object::transition_sentinel().raw());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* const thread = Thread::Current();
     NoOOBMessageScope no_msg_scope(thread);
     NoReloadScope no_reload_scope(thread->isolate(), thread);
     // Under lazy compilation initializer has not yet been created, so create
     // it now, but don't bother remembering it because it won't be used again.
     ASSERT(!field.HasPrecompiledInitializer());
-    Function& initializer = Function::Handle(thread->zone());
     {
 #if !defined(PRODUCT)
       VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
       TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
                                 "CompileStaticInitializer");
       if (tds.enabled()) {
         tds.SetNumArguments(1);
         tds.CopyArgument(0, "field", field.ToCString());
       }
 #endif  // !defined(PRODUCT)
 
       StackZone stack_zone(thread);
       Zone* zone = stack_zone.GetZone();
       ParsedFunction* parsed_function;
 
       // Create a one-time-use function to evaluate the initializer and invoke
       // it immediately.
       if (field.kernel_field() != NULL) {
         parsed_function = kernel::ParseStaticFieldInitializer(zone, field);
       } else {
         parsed_function = Parser::ParseStaticFieldInitializer(field);
         parsed_function->AllocateVariables();
       }
 
       // Non-optimized code generator.
       DartCompilationPipeline pipeline;
       CompileParsedFunctionHelper helper(parsed_function, false, kNoOSRDeoptId);
-      helper.Compile(&pipeline);
-      initializer = parsed_function->function().raw();
-      Code::Handle(initializer.unoptimized_code())
-          .set_var_descriptors(Object::empty_var_descriptors());
+      const Code& code = Code::Handle(helper.Compile(&pipeline));
+      if (!code.IsNull()) {
+        const Function& initializer = parsed_function->function();
+        code.set_var_descriptors(Object::empty_var_descriptors());
+        // Invoke the function to evaluate the expression.
+        return DartEntry::InvokeFunction(initializer, Object::empty_array());
+      }
     }
-    // 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());
-    thread->clear_sticky_error();
-    return error.raw();
   }
-  UNREACHABLE();
-  return Object::null();
+
+  Thread* const thread = Thread::Current();
+  StackZone zone(thread);
+  const Error& error = Error::Handle(thread->zone(), thread->sticky_error());
+  thread->clear_sticky_error();
+  return error.raw();
 }
 
 
 RawObject* Compiler::ExecuteOnce(SequenceNode* fragment) {
 #ifdef DART_PRECOMPILER
   if (FLAG_precompiled_mode) {
     return Precompiler::ExecuteOnce(fragment);
   }
 #endif
   LongJumpScope jump;
@@ skipping 42 matching lines @@
     // 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.
     DartCompilationPipeline pipeline;
     CompileParsedFunctionHelper helper(parsed_function, false, kNoOSRDeoptId);
-    helper.Compile(&pipeline);
-    Code::Handle(func.unoptimized_code())
-        .set_var_descriptors(Object::empty_var_descriptors());
+    const Code& code = Code::Handle(helper.Compile(&pipeline));
+    if (!code.IsNull()) {
+      code.set_var_descriptors(Object::empty_var_descriptors());
+      const Object& result = PassiveObject::Handle(
+          DartEntry::InvokeFunction(func, Object::empty_array()));
+      return result.raw();
+    }
+  }
 
-    const Object& result = PassiveObject::Handle(
-        DartEntry::InvokeFunction(func, Object::empty_array()));
-    return result.raw();
-  } else {
-    Thread* const thread = Thread::Current();
-    const Object& result = PassiveObject::Handle(thread->sticky_error());
-    thread->clear_sticky_error();
-    return result.raw();
-  }
-  UNREACHABLE();
-  return Object::null();
+  Thread* const thread = Thread::Current();
+  const Object& result = PassiveObject::Handle(thread->sticky_error());
+  thread->clear_sticky_error();
+  return result.raw();
 }
 
 
 void Compiler::AbortBackgroundCompilation(intptr_t deopt_id, const char* msg) {
   if (FLAG_trace_compiler) {
     THR_Print("ABORT background compilation: %s\n", msg);
   }
 #if !defined(PRODUCT)
   TimelineStream* stream = Timeline::GetCompilerStream();
   ASSERT(stream != NULL);
@@ skipping 487 matching lines @@
 
 
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart