[kernel] [partial] Streaming of kernel binary without AST nodes

runtime/vm/kernel_to_il.h

 // 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.
 
 #ifndef RUNTIME_VM_KERNEL_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/growable_array.h"
@@ skipping 329 matching lines @@
   dart::String& DartSymbol(const uint8_t* utf8_array, intptr_t len) const;
 
   const dart::String& DartClassName(NameIndex kernel_class);
 
   const dart::String& DartConstructorName(NameIndex constructor);
 
   const dart::String& DartProcedureName(NameIndex procedure);
 
   const dart::String& DartSetterName(NameIndex setter);
   const dart::String& DartSetterName(Name* setter_name);
+  const dart::String& DartSetterName(NameIndex parent, StringIndex setter);
 
   const dart::String& DartGetterName(NameIndex getter);
   const dart::String& DartGetterName(Name* getter_name);
+  const dart::String& DartGetterName(NameIndex parent, StringIndex getter);
 
   const dart::String& DartFieldName(Name* kernel_name);
 
   const dart::String& DartInitializerName(Name* kernel_name);
 
   const dart::String& DartMethodName(NameIndex method);
   const dart::String& DartMethodName(Name* method_name);
+  const dart::String& DartMethodName(NameIndex parent, StringIndex method);
 
   const dart::String& DartFactoryName(NameIndex factory);
 
   const Array& ArgumentNames(List<NamedExpression>* named);
 
   // A subclass overrides these when reading in the Kernel program in order to
   // support recursive type expressions (e.g. for "implements X" ...
   // annotations).
   virtual RawLibrary* LookupLibraryByKernelLibrary(NameIndex library);
   virtual RawClass* LookupClassByKernelClass(NameIndex klass);
@@ skipping 12 matching lines @@
 
  private:
   // This will mangle [name_to_modify] if necessary and make the result a symbol
   // if asked.  The result will be available in [name_to_modify] and it is also
   // returned.  If the name is private, the canonical name [parent] will be used
   // to get the import URI of the library where the name is visible.
   dart::String& ManglePrivateName(NameIndex parent,
                                   dart::String* name_to_modify,
                                   bool symbolize = true);
 
-  const dart::String& DartSetterName(NameIndex parent, StringIndex setter);
-  const dart::String& DartGetterName(NameIndex parent, StringIndex getter);
-  const dart::String& DartMethodName(NameIndex parent, StringIndex method);
 
   Thread* thread_;
   Zone* zone_;
   Isolate* isolate_;
   Heap::Space allocation_space_;
 
   TypedData& string_offsets_;
   TypedData& string_data_;
   TypedData& canonical_names_;
 };
@@ skipping 358 matching lines @@
   FunctionNode* current_function_node_;
   LocalScope* current_function_scope_;
   LocalScope* scope_;
   DepthState depth_;
 
   intptr_t name_index_;
 
   bool needs_expr_temp_;
 };
 
+struct YieldContinuation {
+  Instruction* entry;
+  intptr_t try_index;
+
+  YieldContinuation(Instruction* entry, intptr_t try_index)
+      : entry(entry), try_index(try_index) {}
+
+  YieldContinuation()
+      : entry(NULL), try_index(CatchClauseNode::kInvalidTryIndex) {}
+};
+
 class FlowGraphBuilder : public ExpressionVisitor, public StatementVisitor {
  public:
   FlowGraphBuilder(TreeNode* node,
                    ParsedFunction* parsed_function,
                    const ZoneGrowableArray<const ICData*>& ic_data_array,
                    InlineExitCollector* exit_collector,
                    intptr_t osr_id,
                    intptr_t first_block_id = 1);
   virtual ~FlowGraphBuilder();
 
@@ skipping 90 matching lines @@
   Fragment TranslateStatement(Statement* statement);
   Fragment TranslateCondition(Expression* expression, bool* negate);
   Fragment TranslateExpression(Expression* expression);
 
   Fragment TranslateFinallyFinalizers(TryFinallyBlock* outer_finally,
                                       intptr_t target_context_depth);
 
   Fragment TranslateFunctionNode(FunctionNode* node, TreeNode* parent);
 
   Fragment EnterScope(TreeNode* node, bool* new_context = NULL);
+  Fragment EnterScope(intptr_t kernel_offset, bool* new_context = NULL);
   Fragment ExitScope(TreeNode* node);
+  Fragment ExitScope(intptr_t kernel_offset);
 
   Fragment LoadContextAt(int depth);
   Fragment AdjustContextTo(int depth);
 
   Fragment PushContext(int size);
   Fragment PopContext();
 
   Fragment LoadInstantiatorTypeArguments();
   Fragment LoadFunctionTypeArguments();
   Fragment InstantiateType(const AbstractType& type);
@@ skipping 82 matching lines @@
   Fragment StringInterpolateSingle(TokenPosition position);
   Fragment ThrowTypeError();
   Fragment ThrowNoSuchMethodError();
   Fragment BuildImplicitClosureCreation(const Function& target);
   Fragment GuardFieldLength(const dart::Field& field, intptr_t deopt_id);
   Fragment GuardFieldClass(const dart::Field& field, intptr_t deopt_id);
 
   Fragment EvaluateAssertion();
   Fragment CheckReturnTypeInCheckedMode();
   Fragment CheckVariableTypeInCheckedMode(VariableDeclaration* variable);
+  Fragment CheckVariableTypeInCheckedMode(const AbstractType& dst_type,
+                                          const dart::String& name_symbol);
   Fragment CheckBooleanInCheckedMode();
   Fragment CheckAssignableInCheckedMode(const dart::AbstractType& dst_type,
                                         const dart::String& dst_name);
 
   Fragment AssertBool();
   Fragment AssertAssignable(const dart::AbstractType& dst_type,
                             const dart::String& dst_name);
 
   template <class Invocation>
   bool RecognizeComparisonWithNull(Token::Kind token_kind, Invocation* node);
 
   bool NeedsDebugStepCheck(const Function& function, TokenPosition position);
   bool NeedsDebugStepCheck(Value* value, TokenPosition position);
   Fragment DebugStepCheck(TokenPosition position);
 
   dart::RawFunction* LookupMethodByMember(NameIndex target,
                                           const dart::String& method_name);
 
   LocalVariable* MakeTemporary();
   LocalVariable* MakeNonTemporary(const dart::String& symbol);
 
   intptr_t CurrentTryIndex();
   intptr_t AllocateTryIndex() { return next_used_try_index_++; }
 
   void AddVariable(VariableDeclaration* declaration, LocalVariable* variable);
   void AddParameter(VariableDeclaration* declaration,
                     LocalVariable* variable,
                     intptr_t pos);
   dart::LocalVariable* LookupVariable(VariableDeclaration* var);
+  dart::LocalVariable* LookupVariable(intptr_t kernel_offset);
 
   void SetTempIndex(Definition* definition);
 
   void Push(Definition* definition);
   Value* Pop();
   Fragment Drop();
 
   bool IsInlining() { return exit_collector_ != NULL; }
 
   Token::Kind MethodKind(const dart::String& name);
@@ skipping 24 matching lines @@
   intptr_t catch_depth_;
   intptr_t for_in_depth_;
   Fragment fragment_;
   Value* stack_;
   intptr_t pending_argument_count_;
 
   GraphEntryInstr* graph_entry_;
 
   ScopeBuildingResult* scopes_;
 
-  struct YieldContinuation {
-    Instruction* entry;
-    intptr_t try_index;
-
-    YieldContinuation(Instruction* entry, intptr_t try_index)
-        : entry(entry), try_index(try_index) {}
-
-    YieldContinuation()
-        : entry(NULL), try_index(CatchClauseNode::kInvalidTryIndex) {}
-  };
-
   GrowableArray<YieldContinuation> yield_continuations_;
 
   LocalVariable* CurrentException() {
     return scopes_->exception_variables[catch_depth_ - 1];
   }
   LocalVariable* CurrentStackTrace() {
     return scopes_->stack_trace_variables[catch_depth_ - 1];
   }
   LocalVariable* CurrentCatchContext() {
     return scopes_->catch_context_variables[try_depth_];
@@ skipping 32 matching lines @@
   friend class ConstantEvaluator;
   friend class DartTypeTranslator;
   friend class StreamingFlowGraphBuilder;
   friend class ScopeBuilder;
   friend class SwitchBlock;
   friend class TryCatchBlock;
   friend class TryFinallyBlock;
 };
 
 
+class SwitchBlock {
+ public:
+  SwitchBlock(FlowGraphBuilder* builder, intptr_t num_cases)
+      : builder_(builder),
+        outer_(builder->switch_block_),
+        outer_finally_(builder->try_finally_block_),
+        num_cases_(num_cases),
+        context_depth_(builder->context_depth_),
+        try_index_(builder->CurrentTryIndex()) {
+    builder_->switch_block_ = this;
+    if (outer_ != NULL) {
+      depth_ = outer_->depth_ + outer_->num_cases_;
+    } else {
+      depth_ = 0;
+    }
+  }
+  ~SwitchBlock() { builder_->switch_block_ = outer_; }
+
+  bool HadJumper(intptr_t case_num) {
+    return destinations_.Lookup(case_num) != NULL;
+  }
+
+  // Get destination via absolute target number (i.e. the correct destination
+  // is not not necessarily in this block.
+  JoinEntryInstr* Destination(intptr_t target_index,
+                              TryFinallyBlock** outer_finally = NULL,
+                              intptr_t* context_depth = NULL) {
+    // Find corresponding [SwitchStatement].
+    SwitchBlock* block = this;
+    while (block->depth_ > target_index) {
+      block = block->outer_;
+    }
+
+    // Set the outer finally block.
+    if (outer_finally != NULL) {
+      *outer_finally = block->outer_finally_;
+      *context_depth = block->context_depth_;
+    }
+
+    // Ensure there's [JoinEntryInstr] for that [SwitchCase].
+    return block->EnsureDestination(target_index - block->depth_);
+  }
+
+  // Get destination via relative target number (i.e. relative to this block,
+  // 0 is first case in this block etc).
+  JoinEntryInstr* DestinationDirect(intptr_t case_num,
+                                    TryFinallyBlock** outer_finally = NULL,
+                                    intptr_t* context_depth = NULL) {
+    // Set the outer finally block.
+    if (outer_finally != NULL) {
+      *outer_finally = outer_finally_;
+      *context_depth = context_depth_;
+    }
+
+    // Ensure there's [JoinEntryInstr] for that [SwitchCase].
+    return EnsureDestination(case_num);
+  }
+
+ private:
+  JoinEntryInstr* EnsureDestination(intptr_t case_num) {
+    JoinEntryInstr* cached_inst = destinations_.Lookup(case_num);
+    if (cached_inst == NULL) {
+      JoinEntryInstr* inst = builder_->BuildJoinEntry(try_index_);
+      destinations_.Insert(case_num, inst);
+      return inst;
+    }
+    return cached_inst;
+  }
+
+  FlowGraphBuilder* builder_;
+  SwitchBlock* outer_;
+
+  IntMap<JoinEntryInstr*> destinations_;
+
+  TryFinallyBlock* outer_finally_;
+  intptr_t num_cases_;
+  intptr_t depth_;
+  intptr_t context_depth_;
+  intptr_t try_index_;
+};
+
+
+class TryCatchBlock {
+ public:
+  explicit TryCatchBlock(FlowGraphBuilder* builder,
+                         intptr_t try_handler_index = -1)
+      : builder_(builder),
+        outer_(builder->try_catch_block_),
+        try_index_(try_handler_index) {
+    if (try_index_ == -1) try_index_ = builder->AllocateTryIndex();
+    builder->try_catch_block_ = this;
+  }
+  ~TryCatchBlock() { builder_->try_catch_block_ = outer_; }
+
+  intptr_t try_index() { return try_index_; }
+  TryCatchBlock* outer() const { return outer_; }
+
+ private:
+  FlowGraphBuilder* builder_;
+  TryCatchBlock* outer_;
+  intptr_t try_index_;
+};
+
+
+class TryFinallyBlock {
+ public:
+  TryFinallyBlock(FlowGraphBuilder* builder,
+                  Statement* finalizer,
+                  intptr_t finalizer_kernel_offset)
+      : builder_(builder),
+        outer_(builder->try_finally_block_),
+        finalizer_(finalizer),
+        finalizer_kernel_offset_(finalizer_kernel_offset),
+        context_depth_(builder->context_depth_),
+        // Finalizers are executed outside of the try block hence
+        // try depth of finalizers are one less than current try
+        // depth.
+        try_depth_(builder->try_depth_ - 1),
+        try_index_(builder_->CurrentTryIndex()) {
+    builder_->try_finally_block_ = this;
+  }
+  ~TryFinallyBlock() { builder_->try_finally_block_ = outer_; }
+
+  Statement* finalizer() const { return finalizer_; }
+  intptr_t finalizer_kernel_offset() const { return finalizer_kernel_offset_; }
+  intptr_t context_depth() const { return context_depth_; }
+  intptr_t try_depth() const { return try_depth_; }
+  intptr_t try_index() const { return try_index_; }
+  TryFinallyBlock* outer() const { return outer_; }
+
+ private:
+  FlowGraphBuilder* const builder_;
+  TryFinallyBlock* const outer_;
+  Statement* const finalizer_;
+  intptr_t finalizer_kernel_offset_;
+  const intptr_t context_depth_;
+  const intptr_t try_depth_;
+  const intptr_t try_index_;
+};
+
+
+class BreakableBlock {
+ public:
+  explicit BreakableBlock(FlowGraphBuilder* builder)
+      : builder_(builder),
+        outer_(builder->breakable_block_),
+        destination_(NULL),
+        outer_finally_(builder->try_finally_block_),
+        context_depth_(builder->context_depth_),
+        try_index_(builder->CurrentTryIndex()) {
+    if (builder_->breakable_block_ == NULL) {
+      index_ = 0;
+    } else {
+      index_ = builder_->breakable_block_->index_ + 1;
+    }
+    builder_->breakable_block_ = this;
+  }
+  ~BreakableBlock() { builder_->breakable_block_ = outer_; }
+
+  bool HadJumper() { return destination_ != NULL; }
+
+  JoinEntryInstr* destination() { return destination_; }
+
+  JoinEntryInstr* BreakDestination(intptr_t label_index,
+                                   TryFinallyBlock** outer_finally,
+                                   intptr_t* context_depth) {
+    BreakableBlock* block = builder_->breakable_block_;
+    while (block->index_ != label_index) {
+      block = block->outer_;
+    }
+    ASSERT(block != NULL);
+    *outer_finally = block->outer_finally_;
+    *context_depth = block->context_depth_;
+    return block->EnsureDestination();
+  }
+
+ private:
+  JoinEntryInstr* EnsureDestination() {
+    if (destination_ == NULL) {
+      destination_ = builder_->BuildJoinEntry(try_index_);
+    }
+    return destination_;
+  }
+
+  FlowGraphBuilder* builder_;
+  intptr_t index_;
+  BreakableBlock* outer_;
+  JoinEntryInstr* destination_;
+  TryFinallyBlock* outer_finally_;
+  intptr_t context_depth_;
+  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),
@@ skipping 31 matching lines @@
 namespace kernel {
 
 RawObject* EvaluateMetadata(const dart::Field& metadata_field);
 RawObject* BuildParameterDescriptor(const Function& function);
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_