Initial steps into streaming the kernel flowgraph

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
 #include "vm/kernel_reader.h"
+#include "vm/kernel_binary_flowgraph.h"
 #include "vm/longjump.h"
 #include "vm/method_recognizer.h"
 #include "vm/object_store.h"
 #include "vm/report.h"
 #include "vm/resolver.h"
 #include "vm/stack_frame.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 namespace dart {
 
@@ skipping 931 matching lines @@
   intptr_t try_index() { return try_index_; }
   TryCatchBlock* outer() const { return outer_; }
 
  private:
   FlowGraphBuilder* builder_;
   TryCatchBlock* outer_;
   intptr_t try_index_;
 };
 
 
-class CatchBlock {
- public:
-  CatchBlock(FlowGraphBuilder* builder,
-             LocalVariable* exception_var,
-             LocalVariable* stack_trace_var,
-             intptr_t catch_try_index)
-      : builder_(builder),
-        outer_(builder->catch_block_),
-        exception_var_(exception_var),
-        stack_trace_var_(stack_trace_var),
-        catch_try_index_(catch_try_index) {
-    builder_->catch_block_ = this;
-  }
-  ~CatchBlock() { builder_->catch_block_ = outer_; }
-
-  LocalVariable* exception_var() { return exception_var_; }
-  LocalVariable* stack_trace_var() { return stack_trace_var_; }
-  intptr_t catch_try_index() { return catch_try_index_; }
-
- private:
-  FlowGraphBuilder* builder_;
-  CatchBlock* outer_;
-  LocalVariable* exception_var_;
-  LocalVariable* stack_trace_var_;
-  intptr_t catch_try_index_;
-};
-
-
 Fragment& Fragment::operator+=(const Fragment& other) {
   if (entry == NULL) {
     entry = other.entry;
     current = other.current;
   } else if (current != NULL && other.entry != NULL) {
     current->LinkTo(other.entry);
     current = other.current;
   }
   return *this;
 }
@@ skipping 931 matching lines @@
       scopes_(NULL),
       breakable_block_(NULL),
       switch_block_(NULL),
       try_finally_block_(NULL),
       try_catch_block_(NULL),
       next_used_try_index_(0),
       catch_block_(NULL),
       type_translator_(&translation_helper_,
                        &active_class_,
                        /* finalize= */ true),
-      constant_evaluator_(this,
-                          zone_,
-                          &translation_helper_,
-                          &type_translator_) {}
+      constant_evaluator_(this, zone_, &translation_helper_, &type_translator_),
+      library_(NULL) {}
 
 
 FlowGraphBuilder::~FlowGraphBuilder() {}
 
 
 Fragment FlowGraphBuilder::TranslateFinallyFinalizers(
     TryFinallyBlock* outer_finally,
     intptr_t target_context_depth) {
   TryFinallyBlock* const saved_block = try_finally_block_;
   TryCatchBlock* const saved_try_catch_block = try_catch_block_;
@@ skipping 1031 matching lines @@
     parsed_function_->Bailout("kernel::FlowGraphBuilder", reason);
   }
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraph() {
   const dart::Function& function = parsed_function_->function();
 
   if (function.IsConstructorClosureFunction()) return NULL;
 
+  TreeNode* library_node = node_;
+  if (node_ != NULL) {
+    const dart::Function* parent = &function;
+    while (true) {
+      library_node = static_cast<kernel::TreeNode*>(parent->kernel_function());
+      while (library_node != NULL && !library_node->IsLibrary()) {
+        if (library_node->IsMember()) {
+          library_node = Member::Cast(library_node)->parent();
+        } else if (library_node->IsClass()) {
+          library_node = Class::Cast(library_node)->parent();
+          break;
+        } else {
+          library_node = NULL;
+          break;
+        }
+      }
+      if (library_node != NULL) break;
+      parent = &dart::Function::Handle(parent->parent_function());
+    }
+  }
+  if (library_node != NULL && library_node->IsLibrary()) {
+    library_ = Library::Cast(library_node);
+  } else {
+    library_ = NULL;
+  }
+
   dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function_->function().Owner());
 
   Function& outermost_function = Function::Handle(Z);
   TreeNode* outermost_node = NULL;
   Class* kernel_klass = NULL;
   DiscoverEnclosingElements(Z, function, &outermost_function, &outermost_node,
                             &kernel_klass);
 
   // Mark that we are using [klass]/[kernell_klass] as active class.  Resolving
@@ skipping 2311 matching lines @@
   }
   instructions += PushArgument();
   instructions += ThrowException(node->position());
   ASSERT(instructions.is_closed());
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitRethrow(Rethrow* node) {
-  Fragment instructions;
-
-  instructions = DebugStepCheck(node->position()) + instructions;

[Kevin Millikin (Google), 2017/03/28 12:50:00]

This is pretty weird.

[jensj, 2017/03/29 09:30:42]

Yeah, sorry about that :x

-  instructions += LoadLocal(catch_block_->exception_var());
-  instructions += PushArgument();
-  instructions += LoadLocal(catch_block_->stack_trace_var());
-  instructions += PushArgument();
-  instructions +=
-      RethrowException(node->position(), catch_block_->catch_try_index());
-
-  fragment_ = instructions;
+  KernelFlowgraphBuilder builder(this, library_->kernel_data(),
+                                 library_->kernel_data_size());
+  fragment_ = builder.BuildAt(node->kernel_offset());
 }
 
 
 Fragment FlowGraphBuilder::TranslateArguments(Arguments* node,
                                               Array* argument_names) {
   Fragment instructions;
 
   List<Expression>& positional = node->positional();
   for (intptr_t i = 0; i < positional.length(); ++i) {
     instructions += TranslateExpression(positional[i]);
@@ skipping 1111 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)