[kernel] Insert kernel bodies into VM heap

runtime/vm/kernel_binary_flowgraph.h

 // Copyright (c) 2017, 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_BINARY_FLOWGRAPH_H_
 #define RUNTIME_VM_KERNEL_BINARY_FLOWGRAPH_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include <map>
@@ skipping 33 matching lines @@
  private:
   // Can build a malformed type.
   void BuildTypeInternal();
   void BuildInterfaceType(bool simple);
   void BuildFunctionType(bool simple);
   void BuildTypeParameterType();
 
   class TypeParameterScope {
    public:
     TypeParameterScope(StreamingDartTypeTranslator* translator,
-                       intptr_t parameters_offset,
                        intptr_t parameters_count)
-        : parameters_offset_(parameters_offset),
-          parameters_count_(parameters_count),
+        : parameters_count_(parameters_count),

[Kevin Millikin (Google), 2017/08/09 12:08:51]

parameter_count_

[jensj, 2017/08/10 07:37:34]

Done.

           outer_(translator->type_parameter_scope_),
           translator_(translator) {
       summed_outer_parameters_count_ = 0;
       if (outer_ != NULL) {
         summed_outer_parameters_count_ =
             outer_->summed_outer_parameters_count_ + outer_->parameters_count_;
       }
       translator_->type_parameter_scope_ = this;
     }
     ~TypeParameterScope() { translator_->type_parameter_scope_ = outer_; }
 
     TypeParameterScope* outer() const { return outer_; }
-    intptr_t parameters_offset() const { return parameters_offset_; }
     intptr_t parameters_count() const { return parameters_count_; }
     intptr_t summed_outer_parameters_count() const {
       return summed_outer_parameters_count_;
     }
 
    private:
-    intptr_t parameters_offset_;
     intptr_t parameters_count_;
     intptr_t summed_outer_parameters_count_;
     TypeParameterScope* outer_;
     StreamingDartTypeTranslator* translator_;
   };
 
   intptr_t FindTypeParameterIndex(intptr_t parameters_offset,
                                   intptr_t parameters_count,
                                   intptr_t look_for);
 
   StreamingFlowGraphBuilder* builder_;
   TranslationHelper& translation_helper_;
   ActiveClass* active_class_;
   TypeParameterScope* type_parameter_scope_;
   Zone* zone_;
   AbstractType& result_;
   bool finalize_;
 
   friend class StreamingScopeBuilder;
   friend class KernelReader;
 };
 
 class StreamingScopeBuilder {
  public:
   StreamingScopeBuilder(ParsedFunction* parsed_function,
-                        intptr_t kernel_offset,
-                        const uint8_t* buffer,
-                        intptr_t buffer_length);
+                        intptr_t relative_kernel_offset,
+                        const TypedData& body);
 
   virtual ~StreamingScopeBuilder();
 
   ScopeBuildingResult* BuildScopes();
 
  private:
   void VisitField();
 
   void VisitProcedure();
 
@@ skipping 37 matching lines @@
                             intptr_t nesting_depth);
 
   void AddTryVariables();
   void AddCatchVariables();
   void AddIteratorVariable();
   void AddSwitchVariable();
 
   // Record an assignment or reference to a variable.  If the occurrence is
   // in a nested function, ensure that the variable is handled properly as a
   // captured variable.
-  void LookupVariable(intptr_t declaration_binary_offest);
+  void LookupVariable(intptr_t declaration_binary_offset);
 
   const dart::String& GenerateName(const char* prefix, intptr_t suffix);
 
   void HandleSpecialLoad(LocalVariable** variable, const dart::String& symbol);
   void LookupCapturedVariableByName(LocalVariable** variable,
                                     const dart::String& name);
 
   struct DepthState {
     explicit DepthState(intptr_t function)
         : loop_(0),
           function_(function),
           try_(0),
           catch_(0),
           finally_(0),
           for_in_(0) {}
 
     intptr_t loop_;
     intptr_t function_;
     intptr_t try_;
     intptr_t catch_;
     intptr_t finally_;
     intptr_t for_in_;
   };
 
   ScopeBuildingResult* result_;
   ParsedFunction* parsed_function_;
-  intptr_t kernel_offset_;
+  intptr_t relative_kernel_offset_;
 
   ActiveClass active_class_;
 
   TranslationHelper translation_helper_;
   Zone* zone_;
 
   FunctionNode::AsyncMarker current_function_async_marker_;
   LocalScope* current_function_scope_;
   LocalScope* scope_;
   DepthState depth_;
@@ skipping 100 matching lines @@
 
   Script& script_;
   Instance& result_;
 };
 
 class FunctionNodeHelper;
 
 class StreamingFlowGraphBuilder {
  public:
   StreamingFlowGraphBuilder(FlowGraphBuilder* flow_graph_builder,
-                            const uint8_t* buffer,
-                            intptr_t buffer_length)
+                            intptr_t relative_kernel_offset,
+                            const TypedData& body)
       : flow_graph_builder_(flow_graph_builder),
         translation_helper_(flow_graph_builder->translation_helper_),
         zone_(flow_graph_builder->zone_),
-        reader_(new Reader(buffer, buffer_length)),
+        reader_(new Reader(body)),
         constant_evaluator_(this),
         type_translator_(this, /* finalize= */ true),
+        relative_kernel_offset_(relative_kernel_offset),
         current_script_id_(-1),
         record_for_script_id_(-1),
         record_token_positions_into_(NULL),
         record_yield_positions_into_(NULL) {}
 
   StreamingFlowGraphBuilder(TranslationHelper* translation_helper,
                             Zone* zone,
                             const uint8_t* buffer,
                             intptr_t buffer_length)
       : flow_graph_builder_(NULL),
         translation_helper_(*translation_helper),
         zone_(zone),
         reader_(new Reader(buffer, buffer_length)),
         constant_evaluator_(this),
         type_translator_(this, /* finalize= */ true),
+        relative_kernel_offset_(0),
         current_script_id_(-1),
         record_for_script_id_(-1),
         record_token_positions_into_(NULL),
+        record_yield_positions_into_(NULL) {}
+
+  StreamingFlowGraphBuilder(TranslationHelper* translation_helper,
+                            Zone* zone,
+                            intptr_t relative_kernel_offset,
+                            const TypedData& body)
+      : flow_graph_builder_(NULL),
+        translation_helper_(*translation_helper),
+        zone_(zone),
+        reader_(new Reader(body)),
+        constant_evaluator_(this),
+        type_translator_(this, /* finalize= */ true),
+        relative_kernel_offset_(relative_kernel_offset),
+        current_script_id_(-1),
+        record_for_script_id_(-1),
+        record_token_positions_into_(NULL),
         record_yield_positions_into_(NULL) {}
 
   ~StreamingFlowGraphBuilder() { delete reader_; }
 
   FlowGraph* BuildGraph(intptr_t kernel_offset);
 
   Fragment BuildStatementAt(intptr_t kernel_offset);
   RawObject* BuildParameterDescriptor(intptr_t kernel_offset);
   RawObject* EvaluateMetadata(intptr_t kernel_offset);
   void CollectTokenPositionsFor(
       intptr_t script_index,
+      intptr_t initial_script_index,
       GrowableArray<intptr_t>* record_token_positions_in,
       GrowableArray<intptr_t>* record_yield_positions_in);
   intptr_t SourceTableSize();
   String& SourceTableUriFor(intptr_t index);
   String& GetSourceFor(intptr_t index);
   Array& GetLineStartsFor(intptr_t index);
 
  private:
   void DiscoverEnclosingElements(Zone* zone,
                                  const Function& function,
                                  Function* outermost_function);
 
-  /**
-   * Will return kernel offset for parent class if reading a constructor.
-   * Will otherwise return -1.
-   */
-  intptr_t ReadUntilFunctionNode();
-  StringIndex GetNameFromVariableDeclaration(intptr_t kernel_offset);
+  void ReadUntilFunctionNode();
+  StringIndex GetNameFromVariableDeclaration(intptr_t kernel_offset,
+                                             const Function& function);
 
   FlowGraph* BuildGraphOfStaticFieldInitializer();
   FlowGraph* BuildGraphOfFieldAccessor(LocalVariable* setter_value);
   void SetupDefaultParameterValues();
   Fragment BuildFieldInitializer(NameIndex canonical_name);
-  Fragment BuildInitializers(intptr_t constructor_class_parent_offset);
+  Fragment BuildInitializers(const Class& parent_class);
   FlowGraph* BuildGraphOfImplicitClosureFunction(const Function& function);
   FlowGraph* BuildGraphOfConvertedClosureFunction(const Function& function);
-  FlowGraph* BuildGraphOfFunction(
-      intptr_t constructor_class_parent_offset = -1);
+  FlowGraph* BuildGraphOfFunction(bool constructor);
 
   Fragment BuildExpression(TokenPosition* position = NULL);
   Fragment BuildStatement();
 
   intptr_t ReaderOffset();
   void SetOffset(intptr_t offset);
   void SkipBytes(intptr_t skip);
   bool ReadBool();
   uint8_t ReadByte();
   uint32_t ReadUInt();
@@ skipping 225 matching lines @@
   Fragment BuildForInStatement(bool async);
   Fragment BuildSwitchStatement();
   Fragment BuildContinueSwitchStatement();
   Fragment BuildIfStatement();
   Fragment BuildReturnStatement();
   Fragment BuildTryCatch();
   Fragment BuildTryFinally();
   Fragment BuildYieldStatement();
   Fragment BuildVariableDeclaration();
   Fragment BuildFunctionDeclaration();
-  Fragment BuildFunctionNode(intptr_t parent_kernel_offset,
-                             TokenPosition parent_position,
-                             bool declaration,
-                             intptr_t variable_offeset);
+  Fragment BuildFunctionNode(TokenPosition parent_position,
+                             StringIndex name_index);
   void SetupFunctionParameters(const dart::Class& klass,
                                const dart::Function& function,
                                bool is_method,
                                bool is_closure,
                                FunctionNodeHelper* function_node_helper);
 
   FlowGraphBuilder* flow_graph_builder_;
   TranslationHelper& translation_helper_;
   Zone* zone_;
   Reader* reader_;
   StreamingConstantEvaluator constant_evaluator_;
   StreamingDartTypeTranslator type_translator_;
+  intptr_t relative_kernel_offset_;
   intptr_t current_script_id_;
   intptr_t record_for_script_id_;
   GrowableArray<intptr_t>* record_token_positions_into_;
   GrowableArray<intptr_t>* record_yield_positions_into_;
 
   friend class StreamingConstantEvaluator;
   friend class StreamingDartTypeTranslator;
   friend class StreamingScopeBuilder;
   friend class FunctionNodeHelper;
   friend class VariableDeclarationHelper;
@@ skipping 201 matching lines @@
 // "Dumb" fields are stored (e.g. integers) and can be fetched from this class.
 // If asked to read a "non-dumb" field (e.g. an expression) it will be skipped.
 class FieldHelper {
  public:
   enum Fields {
     kStart,  // tag.
     kCanonicalName,
     kPosition,
     kEndPosition,
     kFlags,
-    kParentClassBinaryOffset,
     kName,
     kSourceUriIndex,
     kDocumentationCommentIndex,
     kAnnotations,
     kType,
     kInitializer,
     kEnd
   };
 
   explicit FieldHelper(StreamingFlowGraphBuilder* builder)
@@ skipping 29 matching lines @@
         if (++next_read_ == field) return;
       case kPosition:
         position_ = builder_->ReadPosition(false);  // read position.
         if (++next_read_ == field) return;
       case kEndPosition:
         end_position_ = builder_->ReadPosition(false);  // read end position.
         if (++next_read_ == field) return;
       case kFlags:
         flags_ = builder_->ReadFlags();  // read flags.
         if (++next_read_ == field) return;
-      case kParentClassBinaryOffset:
-        parent_class_binary_offset_ =
-            builder_->ReadUInt();  // read parent class binary offset.
-        if (++next_read_ == field) return;
       case kName:
         builder_->SkipName();  // read name.
         if (++next_read_ == field) return;
       case kSourceUriIndex:
         source_uri_index_ = builder_->ReadUInt();  // read source_uri_index.
         builder_->current_script_id_ = source_uri_index_;
         builder_->record_token_position(position_);
         builder_->record_token_position(end_position_);
         if (++next_read_ == field) return;
       case kDocumentationCommentIndex:
@@ skipping 50 matching lines @@
       *start = function_literal_start_;
       *end = function_literal_end_;
     }
     return has_function_literal_initializer_;
   }
 
   NameIndex canonical_name_;
   TokenPosition position_;
   TokenPosition end_position_;
   word flags_;
-  intptr_t parent_class_binary_offset_;
   intptr_t source_uri_index_;
   intptr_t annotation_count_;
 
  private:
   StreamingFlowGraphBuilder* builder_;
   intptr_t next_read_;
 
   bool has_function_literal_initializer_;
   TokenPosition function_literal_start_;
   TokenPosition function_literal_end_;
 };
 
 // Helper class that reads a kernel Procedure from binary.
 //
 // Use ReadUntilExcluding to read up to but not including a field.
 // One can then for instance read the field from the call-site (and remember to
 // call SetAt to inform this helper class), and then use this to read more.
 // "Dumb" fields are stored (e.g. integers) and can be fetched from this class.
 // If asked to read a "non-dumb" field (e.g. an expression) it will be skipped.
 class ProcedureHelper {
  public:
   enum Fields {
     kStart,  // tag.
     kCanonicalName,
     kPosition,
     kEndPosition,
     kKind,
     kFlags,
-    kParentClassBinaryOffset,
     kName,
     kSourceUriIndex,
     kDocumentationCommentIndex,
     kAnnotations,
     kFunction,
     kEnd
   };
 
   explicit ProcedureHelper(StreamingFlowGraphBuilder* builder) {
     builder_ = builder;
@@ skipping 24 matching lines @@
       case kEndPosition:
         end_position_ = builder_->ReadPosition(false);  // read end position.
         if (++next_read_ == field) return;
       case kKind:
         kind_ = static_cast<Procedure::ProcedureKind>(
             builder_->ReadByte());  // read kind.
         if (++next_read_ == field) return;
       case kFlags:
         flags_ = builder_->ReadFlags();  // read flags.
         if (++next_read_ == field) return;
-      case kParentClassBinaryOffset:
-        parent_class_binary_offset_ =
-            builder_->ReadUInt();  // read parent class binary offset.
-        if (++next_read_ == field) return;
       case kName:
         builder_->SkipName();  // read name.
         if (++next_read_ == field) return;
       case kSourceUriIndex:
         source_uri_index_ = builder_->ReadUInt();  // read source_uri_index.
         builder_->current_script_id_ = source_uri_index_;
         builder_->record_token_position(position_);
         builder_->record_token_position(end_position_);
         if (++next_read_ == field) return;
       case kDocumentationCommentIndex:
@@ skipping 32 matching lines @@
   }
   bool IsConst() {
     return (flags_ & Procedure::kFlagConst) == Procedure::kFlagConst;
   }
 
   NameIndex canonical_name_;
   TokenPosition position_;
   TokenPosition end_position_;
   Procedure::ProcedureKind kind_;
   word flags_;
-  intptr_t parent_class_binary_offset_;
   intptr_t source_uri_index_;
   intptr_t annotation_count_;
 
  private:
   StreamingFlowGraphBuilder* builder_;
   intptr_t next_read_;
 };
 
 // Helper class that reads a kernel Constructor from binary.
 //
 // Use ReadUntilExcluding to read up to but not including a field.
 // One can then for instance read the field from the call-site (and remember to
 // call SetAt to inform this helper class), and then use this to read more.
 // "Dumb" fields are stored (e.g. integers) and can be fetched from this class.
 // If asked to read a "non-dumb" field (e.g. an expression) it will be skipped.
 class ConstructorHelper {
  public:
   enum Fields {
     kStart,  // tag.
     kCanonicalName,
     kPosition,
     kEndPosition,
     kFlags,
-    kParentClassBinaryOffset,
     kName,
     kDocumentationCommentIndex,
     kAnnotations,
     kFunction,
     kInitializers,
     kEnd
   };
 
   explicit ConstructorHelper(StreamingFlowGraphBuilder* builder) {
     builder_ = builder;
@@ skipping 20 matching lines @@
         if (++next_read_ == field) return;
       case kPosition:
         position_ = builder_->ReadPosition();  // read position.
         if (++next_read_ == field) return;
       case kEndPosition:
         end_position_ = builder_->ReadPosition();  // read end position.
         if (++next_read_ == field) return;
       case kFlags:
         flags_ = builder_->ReadFlags();  // read flags.
         if (++next_read_ == field) return;
-      case kParentClassBinaryOffset:
-        parent_class_binary_offset_ =
-            builder_->ReadUInt();  // read parent class binary offset.
-        if (++next_read_ == field) return;
       case kName:
         builder_->SkipName();  // read name.
         if (++next_read_ == field) return;
       case kDocumentationCommentIndex:
         builder_->ReadStringReference();
         if (++next_read_ == field) return;
       case kAnnotations: {
         annotation_count_ = builder_->ReadListLength();  // read list length.
         for (intptr_t i = 0; i < annotation_count_; ++i) {
           builder_->SkipExpression();  // read ith expression.
@@ skipping 48 matching lines @@
     return (flags_ & Constructor::kFlagExternal) == Constructor::kFlagExternal;
   }
   bool IsConst() {
     return (flags_ & Constructor::kFlagConst) == Constructor::kFlagConst;
   }
 
   NameIndex canonical_name_;
   TokenPosition position_;
   TokenPosition end_position_;
   word flags_;
-  intptr_t parent_class_binary_offset_;
   intptr_t annotation_count_;
 
  private:
   StreamingFlowGraphBuilder* builder_;
   intptr_t next_read_;
 };
 
 // Helper class that reads a kernel Class from binary.
 //
 // Use ReadUntilExcluding to read up to but not including a field.
@@ skipping 260 matching lines @@
  private:
   StreamingFlowGraphBuilder* builder_;
   intptr_t next_read_;
 };
 
 // A helper class that saves the current reader position, goes to another reader
 // position, and upon destruction, resets to the original reader position.
 class AlternativeReadingScope {
  public:
   AlternativeReadingScope(Reader* reader, intptr_t new_position)
-      : reader_(reader), saved_offset_(reader_->offset()) {
+      : reader_(reader),
+        saved_size_(reader_->size()),
+        saved_raw_buffer_(reader_->raw_buffer()),
+        saved_typed_data_(reader_->typed_data()),
+        saved_offset_(reader_->offset()) {
+    reader_->set_offset(new_position);
+  }
+
+  AlternativeReadingScope(Reader* reader,
+                          const TypedData* new_typed_data,
+                          intptr_t new_position)
+      : reader_(reader),
+        saved_size_(reader_->size()),
+        saved_raw_buffer_(reader_->raw_buffer()),
+        saved_typed_data_(reader_->typed_data()),
+        saved_offset_(reader_->offset()) {
+    reader_->set_raw_buffer(NULL);
+    reader_->set_typed_data(new_typed_data);
+    reader_->set_size(new_typed_data->Length());
     reader_->set_offset(new_position);
   }
 
   explicit AlternativeReadingScope(Reader* reader)
-      : reader_(reader), saved_offset_(reader_->offset()) {}
+      : reader_(reader),
+        saved_size_(reader_->size()),
+        saved_raw_buffer_(reader_->raw_buffer()),
+        saved_typed_data_(reader_->typed_data()),
+        saved_offset_(reader_->offset()) {}
 
-  ~AlternativeReadingScope() { reader_->set_offset(saved_offset_); }
+  ~AlternativeReadingScope() {
+    reader_->set_raw_buffer(saved_raw_buffer_);
+    reader_->set_typed_data(saved_typed_data_);
+    reader_->set_size(saved_size_);
+    reader_->set_offset(saved_offset_);
+  }
 
   intptr_t saved_offset() { return saved_offset_; }
 
  private:
   Reader* reader_;
+  intptr_t saved_size_;
+  const uint8_t* saved_raw_buffer_;
+  const TypedData* saved_typed_data_;
   intptr_t saved_offset_;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_BINARY_FLOWGRAPH_H_