[kernel] Insert kernel bodies into VM heap

runtime/vm/kernel_binary_flowgraph.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 "vm/kernel_binary_flowgraph.h"
 
 #include "vm/compiler.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 namespace dart {
 namespace kernel {
 
 #define Z (zone_)
 #define H (translation_helper_)
 #define T (type_translator_)
 #define I Isolate::Current()
 
 static bool IsStaticInitializer(const Function& function, Zone* zone) {
   return (function.kind() == RawFunction::kImplicitStaticFinalGetter) &&
          dart::String::Handle(zone, function.name())
              .StartsWith(Symbols::InitPrefix());
 }
 
 StreamingScopeBuilder::StreamingScopeBuilder(ParsedFunction* parsed_function,
-                                             intptr_t kernel_offset,
-                                             const uint8_t* buffer,
-                                             intptr_t buffer_length)
+                                             intptr_t relative_kernel_offset,
+                                             const TypedData& body)
     : result_(NULL),
       parsed_function_(parsed_function),
-      kernel_offset_(kernel_offset),
+      relative_kernel_offset_(relative_kernel_offset),
       translation_helper_(Thread::Current()),
       zone_(translation_helper_.zone()),
       current_function_scope_(NULL),
       scope_(NULL),
       depth_(0),
       name_index_(0),
       needs_expr_temp_(false),
       builder_(new StreamingFlowGraphBuilder(&translation_helper_,
                                              zone_,
-                                             buffer,
-                                             buffer_length)),
+                                             relative_kernel_offset,
+                                             body)),
       type_translator_(builder_, /*finalize=*/true) {
   Script& script = Script::Handle(Z, parsed_function->function().script());
   H.SetStringOffsets(TypedData::Handle(Z, script.kernel_string_offsets()));
   H.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
   H.SetCanonicalNames(TypedData::Handle(Z, script.kernel_canonical_names()));
   type_translator_.active_class_ = &active_class_;
 }
 
 StreamingScopeBuilder::~StreamingScopeBuilder() {
   delete builder_;
 }
 
 ScopeBuildingResult* StreamingScopeBuilder::BuildScopes() {
   if (result_ != NULL) return result_;
 
   ASSERT(scope_ == NULL && depth_.loop_ == 0 && depth_.function_ == 0);
   result_ = new (Z) ScopeBuildingResult();
 
-  ParsedFunction* parsed_function = parsed_function_;
-  const Function& function = parsed_function->function();
+  const Function& function = parsed_function_->function();
 
   // Setup a [ActiveClassScope] and a [ActiveMemberScope] which will be used
   // e.g. for type translation.
   const dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function_->function().Owner());
 
   Function& outermost_function = Function::Handle(Z);
   builder_->DiscoverEnclosingElements(Z, function, &outermost_function);
 
   ActiveClassScope active_class_scope(&active_class_, &klass);
@@ skipping 10 matching lines @@
 
   // Add function type arguments variable before current context variable.
   if (FLAG_reify_generic_functions && function.IsGeneric()) {
     LocalVariable* type_args_var = MakeVariable(
         TokenPosition::kNoSource, TokenPosition::kNoSource,
         Symbols::FunctionTypeArgumentsVar(), AbstractType::dynamic_type());
     scope_->AddVariable(type_args_var);
     parsed_function_->set_function_type_arguments(type_args_var);
   }
 
-  LocalVariable* context_var = parsed_function->current_context_var();
+  LocalVariable* context_var = parsed_function_->current_context_var();
   context_var->set_is_forced_stack();
   scope_->AddVariable(context_var);
 
-  parsed_function->SetNodeSequence(
+  parsed_function_->SetNodeSequence(
       new SequenceNode(TokenPosition::kNoSource, scope_));
 
-  builder_->SetOffset(kernel_offset_);
+  builder_->SetOffset(0);
 
   FunctionNodeHelper function_node_helper(builder_);
 
   switch (function.kind()) {
     case RawFunction::kClosureFunction:
     case RawFunction::kImplicitClosureFunction:
     case RawFunction::kConvertedClosureFunction:
     case RawFunction::kRegularFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor: {
       const Tag tag = builder_->PeekTag();
-      intptr_t parent_offset = builder_->ReadUntilFunctionNode();
+      builder_->ReadUntilFunctionNode();
       function_node_helper.ReadUntilExcluding(
           FunctionNodeHelper::kPositionalParameters);
       current_function_async_marker_ = function_node_helper.async_marker_;
       // NOTE: FunctionNode is read further below the if.
 
       intptr_t pos = 0;
       if (function.IsClosureFunction()) {
         LocalVariable* variable = MakeVariable(
             TokenPosition::kNoSource, TokenPosition::kNoSource,
             Symbols::ClosureParameter(), AbstractType::dynamic_type());
         variable->set_is_forced_stack();
         scope_->InsertParameterAt(pos++, variable);
       } else if (!function.is_static()) {
         // We use [is_static] instead of [IsStaticFunction] because the latter
         // returns `false` for constructors.
         dart::Class& klass = dart::Class::Handle(Z, function.Owner());
         Type& klass_type = H.GetCanonicalType(klass);
         LocalVariable* variable =
             MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                          Symbols::This(), klass_type);
         scope_->InsertParameterAt(pos++, variable);
         result_->this_variable = variable;
 
         // We visit instance field initializers because they might contain
         // [Let] expressions and we need to have a mapping.
         if (tag == kConstructor) {
-          ASSERT(parent_offset >= 0);
-          AlternativeReadingScope alt(builder_->reader_, parent_offset);
-          ClassHelper class_helper(builder_);
-          class_helper.ReadUntilExcluding(ClassHelper::kFields);
-          intptr_t list_length =
-              builder_->ReadListLength();  // read fields list length.
-          for (intptr_t i = 0; i < list_length; i++) {
-            intptr_t field_offset = builder_->ReaderOffset();
-            FieldHelper field_helper(builder_);
-            field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
-            Tag initializer_tag =
-                builder_->ReadTag();  // read first part of initializer.
-            if (!field_helper.IsStatic() && initializer_tag == kSomething) {
-              EnterScope(field_offset);
-              VisitExpression();  // read initializer.
-              ExitScope(field_helper.position_, field_helper.end_position_);
-            } else if (initializer_tag == kSomething) {
-              builder_->SkipExpression();  // read initializer.
+          Class& parent_class = Class::Handle(Z, function.Owner());
+          Array& class_fields = Array::Handle(Z, parent_class.fields());
+          dart::Field& class_field = dart::Field::Handle(Z);
+          for (intptr_t i = 0; i < class_fields.Length(); ++i) {
+            class_field ^= class_fields.At(i);
+            if (!class_field.is_static()) {
+              TypedData& kernel_body =
+                  TypedData::Handle(Z, class_field.kernel_body());
+              ASSERT(!kernel_body.IsNull());
+              AlternativeReadingScope alt(builder_->reader_, &kernel_body, 0);
+              intptr_t saved_relative_kernel_offset_ = relative_kernel_offset_;
+              relative_kernel_offset_ = class_field.kernel_offset();
+              FieldHelper field_helper(builder_);
+              field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
+              Tag initializer_tag =
+                  builder_->ReadTag();  // read first part of initializer.
+              if (initializer_tag == kSomething) {
+                EnterScope(class_field.kernel_offset());
+                VisitExpression();  // read initializer.
+                ExitScope(field_helper.position_, field_helper.end_position_);
+              }
+              relative_kernel_offset_ = saved_relative_kernel_offset_;
             }
           }
         }
       } else if (function.IsFactory()) {
         LocalVariable* variable = MakeVariable(
             TokenPosition::kNoSource, TokenPosition::kNoSource,
             Symbols::TypeArgumentsParameter(), AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, variable);
         result_->type_arguments_variable = variable;
       }
 
       // Continue reading FunctionNode:
       // read positional_parameters and named_parameters.
       AddPositionalAndNamedParameters(pos);
 
-      // We generate a syntethic body for implicit closure functions - which
+      // We generate a synthetic body for implicit closure functions - which
       // will forward the call to the real function.
       //     -> see BuildGraphOfImplicitClosureFunction
       if (!function.IsImplicitClosureFunction()) {
-        builder_->SetOffset(kernel_offset_);
+        builder_->SetOffset(0);
         first_body_token_position_ = TokenPosition::kNoSource;
         VisitNode();
 
         // TODO(jensj): HACK: Push the begin token to after any parameters to
         // avoid crash when breaking on definition line of async method in
         // debugger. It seems that another scope needs to be added
         // in which captures are made, but I can't make that work.
         // This 'solution' doesn't crash, but I cannot see the parameters at
         // that particular breakpoint either.
         // Also push the end token to after the "}" to avoid crashing on
@@ skipping 59 matching lines @@
         scope_->InsertParameterAt(i, variable);
       }
       break;
     case RawFunction::kSignatureFunction:
     case RawFunction::kIrregexpFunction:
       UNREACHABLE();
   }
   if (needs_expr_temp_) {
     scope_->AddVariable(parsed_function_->EnsureExpressionTemp());
   }
-  parsed_function->AllocateVariables();
+  parsed_function_->AllocateVariables();
 
   return result_;
 }
 
 void StreamingScopeBuilder::VisitNode() {
   Tag tag = builder_->PeekTag();
   switch (tag) {
     case kConstructor:
       VisitConstructor();
       return;
@@ skipping 13 matching lines @@
 }
 
 void StreamingScopeBuilder::VisitConstructor() {
   // Field initializers that come from non-static field declarations are
   // compiled as if they appear in the constructor initializer list.  This is
   // important for closure-valued field initializers because the VM expects the
   // corresponding closure functions to appear as if they were nested inside the
   // constructor.
   ConstructorHelper constructor_helper(builder_);
   constructor_helper.ReadUntilExcluding(ConstructorHelper::kFunction);
-  intptr_t parent_offset = constructor_helper.parent_class_binary_offset_;
-  ASSERT(parent_offset >= 0);
   {
-    AlternativeReadingScope alt(builder_->reader_, parent_offset);
-    ClassHelper class_helper(builder_);
-    class_helper.ReadUntilExcluding(ClassHelper::kFields);
-
-    intptr_t list_length =
-        builder_->ReadListLength();  // read fields list length.
-    for (intptr_t i = 0; i < list_length; i++) {
-      FieldHelper field_helper(builder_);
-      field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
-      Tag initializer_tag = builder_->ReadTag();
-      if (!field_helper.IsStatic() && initializer_tag == kSomething) {
-        VisitExpression();  // read initializer.
-      } else if (initializer_tag == kSomething) {
-        builder_->SkipExpression();  // read initializer.
+    const Function& function = parsed_function_->function();
+    Class& parent_class = Class::Handle(Z, function.Owner());
+    Array& class_fields = Array::Handle(Z, parent_class.fields());
+    dart::Field& class_field = dart::Field::Handle(Z);
+    for (intptr_t i = 0; i < class_fields.Length(); ++i) {
+      class_field ^= class_fields.At(i);
+      if (!class_field.is_static()) {
+        TypedData& kernel_body =
+            TypedData::Handle(Z, class_field.kernel_body());
+        ASSERT(!kernel_body.IsNull());
+        AlternativeReadingScope alt(builder_->reader_, &kernel_body, 0);
+        intptr_t saved_relative_kernel_offset_ = relative_kernel_offset_;
+        relative_kernel_offset_ = class_field.kernel_offset();
+        FieldHelper field_helper(builder_);
+        field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
+        Tag initializer_tag = builder_->ReadTag();
+        if (initializer_tag == kSomething) {
+          VisitExpression();  // read initializer.
+        }
+        relative_kernel_offset_ = saved_relative_kernel_offset_;
       }
     }
   }
 
   // Visit children (note that there's no reason to visit the name).
   VisitFunctionNode();
   intptr_t list_length =
       builder_->ReadListLength();  // read initializers list length.
   for (intptr_t i = 0; i < list_length; i++) {
     VisitInitializer();
@@ skipping 293 matching lines @@
       intptr_t offset =
           builder_->ReaderOffset() - 1;  // -1 to include tag byte.
       HandleLocalFunction(offset);       // read function node.
       return;
     }
     case kLet: {
       PositionScope scope(builder_->reader_);
       intptr_t offset =
           builder_->ReaderOffset() - 1;  // -1 to include tag byte.
 
-      EnterScope(offset);
+      EnterScope(relative_kernel_offset_ + offset);
 
       VisitVariableDeclaration();  // read variable declaration.
       VisitExpression();           // read expression.
 
       ExitScope(builder_->reader_->min_position(),
                 builder_->reader_->max_position());
       return;
     }
     case kBigIntLiteral:
       builder_->SkipStringReference();  // read string reference.
@@ skipping 49 matching lines @@
     case kInvalidStatement:
       return;
     case kExpressionStatement:
       VisitExpression();  // read expression.
       return;
     case kBlock: {
       PositionScope scope(builder_->reader_);
       intptr_t offset =
           builder_->ReaderOffset() - 1;  // -1 to include tag byte.
 
-      EnterScope(offset);
+      EnterScope(relative_kernel_offset_ + offset);
 
       intptr_t list_length =
           builder_->ReadListLength();  // read number of statements.
       for (intptr_t i = 0; i < list_length; ++i) {
         VisitStatement();  // read ith statement.
       }
 
       ExitScope(builder_->reader_->min_position(),
                 builder_->reader_->max_position());
       return;
@@ skipping 38 matching lines @@
       VisitStatement();   // read body.
       VisitExpression();  // read condition.
       --depth_.loop_;
       return;
     case kForStatement: {
       PositionScope scope(builder_->reader_);
 
       intptr_t offset =
           builder_->ReaderOffset() - 1;  // -1 to include tag byte.
 
-      EnterScope(offset);
+      EnterScope(relative_kernel_offset_ + offset);
 
       intptr_t list_length =
           builder_->ReadListLength();  // read number of variables.
       for (intptr_t i = 0; i < list_length; ++i) {
         VisitVariableDeclaration();  // read ith variable.
       }
 
       ++depth_.loop_;
 
       Tag tag = builder_->ReadTag();  // Read first part of condition.
@@ skipping 23 matching lines @@
 
       // Notice the ordering: We skip the variable, read the iterable, go back,
       // re-read the variable, go forward to after having read the iterable.
       intptr_t offset = builder_->ReaderOffset();
       builder_->SkipVariableDeclaration();  // read variable.
       VisitExpression();                    // read iterable.
 
       ++depth_.for_in_;
       AddIteratorVariable();
       ++depth_.loop_;
-      EnterScope(start_offset);
+      EnterScope(relative_kernel_offset_ + start_offset);
 
       {
         AlternativeReadingScope alt(builder_->reader_, offset);
         VisitVariableDeclaration();  // read variable.
       }
       VisitStatement();  // read body.
 
       if (!position.IsReal()) {
         position = builder_->reader_->min_position();
       }
@@ skipping 55 matching lines @@
       ++depth_.catch_;
       AddCatchVariables();
 
       builder_->ReadBool();  // read any_catch_needs_stack_trace.
       intptr_t catch_count =
           builder_->ReadListLength();  // read number of catches.
       for (intptr_t i = 0; i < catch_count; ++i) {
         PositionScope scope(builder_->reader_);
         intptr_t offset = builder_->ReaderOffset();  // Catch has no tag.
 
-        EnterScope(offset);
+        EnterScope(relative_kernel_offset_ + offset);
 
         VisitDartType();            // Read the guard.
         tag = builder_->ReadTag();  // read first part of exception.
         if (tag == kSomething) {
           VisitVariableDeclaration();  // read exception.
         }
         tag = builder_->ReadTag();  // read first part of stack trace.
         if (tag == kSomething) {
           VisitVariableDeclaration();  // read stack trace.
         }
@@ skipping 108 matching lines @@
   TokenPosition end_position = builder_->reader_->max_position();
   if (end_position.IsReal()) {
     end_position.Next();
   }
   LocalVariable* variable =
       MakeVariable(helper.position_, end_position, name, type);
   if (helper.IsFinal()) {
     variable->set_is_final();
   }
   scope_->AddVariable(variable);
-  result_->locals.Insert(kernel_offset_no_tag, variable);
+  result_->locals.Insert(relative_kernel_offset_ + kernel_offset_no_tag,
+                         variable);
 }
 
 void StreamingScopeBuilder::VisitDartType() {
   Tag tag = builder_->ReadTag();
   switch (tag) {
     case kInvalidType:
     case kDynamicType:
     case kVoidType:
     case kBottomType:
     case kVectorType:
@@ skipping 88 matching lines @@
 
   FunctionNodeHelper function_node_helper(builder_);
   function_node_helper.ReadUntilExcluding(
       FunctionNodeHelper::kPositionalParameters);
 
   LocalScope* saved_function_scope = current_function_scope_;
   FunctionNode::AsyncMarker saved_function_async_marker =
       current_function_async_marker_;
   StreamingScopeBuilder::DepthState saved_depth_state = depth_;
   depth_ = DepthState(depth_.function_ + 1);
-  EnterScope(parent_kernel_offset);
+  EnterScope(relative_kernel_offset_ + parent_kernel_offset);
   current_function_scope_ = scope_;
   current_function_async_marker_ = function_node_helper.async_marker_;
   if (depth_.function_ == 1) {
-    FunctionScope function_scope = {offset, scope_};
+    FunctionScope function_scope = {relative_kernel_offset_ + offset, scope_};
     result_->function_scopes.Add(function_scope);
   }
 
   // read positional_parameters and named_parameters.
   AddPositionalAndNamedParameters();
 
   // "Peek" is now done.
   builder_->SetOffset(offset);
 
   VisitFunctionNode();  // read function node.
@@ skipping 42 matching lines @@
 
   LocalVariable* variable =
       MakeVariable(helper.position_, helper.position_, name, type);
   if (helper.IsFinal()) {
     variable->set_is_final();
   }
   if (variable->name().raw() == Symbols::IteratorParameter().raw()) {
     variable->set_is_forced_stack();
   }
   scope_->InsertParameterAt(pos, variable);
-  result_->locals.Insert(kernel_offset, variable);
+  result_->locals.Insert(relative_kernel_offset_ + kernel_offset, variable);
 
   // The default value may contain 'let' bindings for which the constant
   // evaluator needs scope bindings.
   Tag tag = builder_->ReadTag();
   if (tag == kSomething) {
     VisitExpression();  // read initializer.
   }
 }
 
 LocalVariable* StreamingScopeBuilder::MakeVariable(
@@ skipping 77 matching lines @@
   if ((depth_.function_ == 0) && (result_->switch_variable == NULL)) {
     LocalVariable* variable =
         MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                      Symbols::SwitchExpr(), AbstractType::dynamic_type());
     variable->set_is_forced_stack();
     current_function_scope_->AddVariable(variable);
     result_->switch_variable = variable;
   }
 }
 
-void StreamingScopeBuilder::LookupVariable(intptr_t declaration_binary_offest) {
-  LocalVariable* variable = result_->locals.Lookup(declaration_binary_offest);
+void StreamingScopeBuilder::LookupVariable(intptr_t declaration_binary_offset) {
+  LocalVariable* variable = result_->locals.Lookup(declaration_binary_offset);
   if (variable == NULL) {
     // We have not seen a declaration of the variable, so it must be the
     // case that we are compiling a nested function and the variable is
     // declared in an outer scope.  In that case, look it up in the scope by
     // name and add it to the variable map to simplify later lookup.
     ASSERT(current_function_scope_->parent() != NULL);
-
-    StringIndex var_name =
-        builder_->GetNameFromVariableDeclaration(declaration_binary_offest);
+    StringIndex var_name = builder_->GetNameFromVariableDeclaration(
+        declaration_binary_offset, parsed_function_->function());
 
     const dart::String& name = H.DartSymbol(var_name);
     variable = current_function_scope_->parent()->LookupVariable(name, true);
     ASSERT(variable != NULL);
-    result_->locals.Insert(declaration_binary_offest, variable);
+    result_->locals.Insert(declaration_binary_offset, variable);
   }
 
   if (variable->owner()->function_level() < scope_->function_level()) {
     // We call `LocalScope->CaptureVariable(variable)` in two scenarios for two
     // different reasons:
     //   Scenario 1:
     //       We need to know which variables defined in this function
     //       are closed over by nested closures in order to ensure we will
     //       create a [Context] object of appropriate size and store captured
     //       variables there instead of the stack.
@@ skipping 155 matching lines @@
       dart::Object::Handle(Z, H.LookupClassByKernelClass(klass_name));
   result_ = Type::New(klass, type_arguments, TokenPosition::kNoSource);
   if (finalize_) {
     ASSERT(active_class_->klass != NULL);
     result_ = ClassFinalizer::FinalizeType(*active_class_->klass, result_);
   }
 }
 
 void StreamingDartTypeTranslator::BuildFunctionType(bool simple) {
   intptr_t list_length = 0;
-  intptr_t first_item_offest = -1;
   if (!simple) {
     list_length =
         builder_->ReadListLength();  // read type_parameters list length
-    first_item_offest = builder_->ReaderOffset();
     for (int i = 0; i < list_length; ++i) {
       builder_->SkipStringReference();  // read string index (name).
       builder_->SkipDartType();         // read dart type.
     }
   }
 
   // The spec describes in section "19.1 Static Types":
   //
   //     Any use of a malformed type gives rise to a static warning. A
   //     malformed type is then interpreted as dynamic by the static type
   //     checker and the runtime unless explicitly specified otherwise.
   //
   // So we convert malformed return/parameter types to `dynamic`.
-  TypeParameterScope scope(this, first_item_offest, list_length);
+  TypeParameterScope scope(this, list_length);
 
   Function& signature_function = Function::ZoneHandle(
       Z,
       Function::NewSignatureFunction(*active_class_->klass, Function::Handle(Z),
                                      TokenPosition::kNoSource));
 
   intptr_t required_count;
   intptr_t all_count;
   intptr_t positional_count;
   if (!simple) {
@@ skipping 729 matching lines @@
 
   // NOTE: This needs to be kept in sync with `runtime/lib/immutable_map.dart`!
   result_ = Instance::New(map_class, Heap::kOld);
   ASSERT(!result_.IsNull());
   result_.SetTypeArguments(type_arguments);
   result_.SetField(field, const_kv_array);
   result_ = H.Canonicalize(result_);
 }
 
 void StreamingConstantEvaluator::EvaluateLet() {
-  intptr_t kernel_position = builder_->ReaderOffset();
+  intptr_t kernel_position =
+      builder_->ReaderOffset() + builder_->relative_kernel_offset_;
   LocalVariable* local = builder_->LookupVariable(kernel_position);
 
   // read variable declaration.
   VariableDeclarationHelper helper(builder_);
   helper.ReadUntilExcluding(VariableDeclarationHelper::kInitializer);
   Tag tag = builder_->ReadTag();  // read (first part of) initializer.
   if (tag == kNothing) {
     local->SetConstValue(Instance::ZoneHandle(Z, dart::Instance::null()));
   } else {
     local->SetConstValue(EvaluateExpression(
@@ skipping 184 matching lines @@
     // evaluated only once.
     return false;
   }
 
   bool is_present = false;
   ASSERT(!script_.InVMHeap());
   if (script_.compile_time_constants() == Array::null()) {
     return false;
   }
   KernelConstantsMap constants(script_.compile_time_constants());
-  *value ^= constants.GetOrNull(kernel_offset, &is_present);
+  *value ^= constants.GetOrNull(
+      kernel_offset + builder_->relative_kernel_offset_, &is_present);
   // Mutator compiler thread may add constants while background compiler
   // is running, and thus change the value of 'compile_time_constants';
   // do not assert that 'compile_time_constants' has not changed.
   constants.Release();
   if (FLAG_compiler_stats && is_present) {
     ++H.thread()->compiler_stats()->num_const_cache_hits;
   }
   return is_present;
 }
 
@@ skipping 10 matching lines @@
     return;
   }
   const intptr_t kInitialConstMapSize = 16;
   ASSERT(!script_.InVMHeap());
   if (script_.compile_time_constants() == Array::null()) {
     const Array& array = Array::Handle(
         HashTables::New<KernelConstantsMap>(kInitialConstMapSize, Heap::kNew));
     script_.set_compile_time_constants(array);
   }
   KernelConstantsMap constants(script_.compile_time_constants());
-  constants.InsertNewOrGetValue(kernel_offset, value);
+  constants.InsertNewOrGetValue(
+      kernel_offset + builder_->relative_kernel_offset_, value);
   script_.set_compile_time_constants(constants.Release());
 }
 
 void StreamingFlowGraphBuilder::DiscoverEnclosingElements(
     Zone* zone,
     const Function& function,
     Function* outermost_function) {
   // Find out if there is an enclosing kernel class (which will be used to
   // resolve type parameters).
   *outermost_function = function.raw();
   while (outermost_function->parent_function() != Object::null()) {
     *outermost_function = outermost_function->parent_function();
   }
 }
 
-intptr_t StreamingFlowGraphBuilder::ReadUntilFunctionNode() {
+void StreamingFlowGraphBuilder::ReadUntilFunctionNode() {
   const Tag tag = PeekTag();
   if (tag == kProcedure) {
     ProcedureHelper procedure_helper(this);
     procedure_helper.ReadUntilExcluding(ProcedureHelper::kFunction);
     if (ReadTag() == kNothing) {  // read function node tag.
       // Running a procedure without a function node doesn't make sense.
       UNREACHABLE();
     }
-    return -1;
+    return;
     // Now at start of FunctionNode.
   } else if (tag == kConstructor) {
     ConstructorHelper constructor_helper(this);
     constructor_helper.ReadUntilExcluding(ConstructorHelper::kFunction);
-    return constructor_helper.parent_class_binary_offset_;
+    return;
     // Now at start of FunctionNode.
     // Notice that we also have a list of initializers after that!
   } else if (tag == kFunctionNode) {
     // Already at start of FunctionNode.
   } else {
     UNREACHABLE();
   }
-  return -1;
+  return;
 }
 
 StringIndex StreamingFlowGraphBuilder::GetNameFromVariableDeclaration(
-    intptr_t kernel_offset) {
+    intptr_t kernel_offset,
+    const Function& function) {
+  Function& function_or_parent = Function::Handle(Z, function.raw());
+  intptr_t function_start_relative =
+      function_or_parent.kernel_offset() - kernel_offset;
+  while (function_start_relative > 0) {
+    function_or_parent = function_or_parent.parent_function();
+    function_start_relative =
+        function_or_parent.kernel_offset() - kernel_offset;
+  }
+  TypedData& kernel_body =
+      TypedData::Handle(Z, function_or_parent.kernel_body());
+  ASSERT(!kernel_body.IsNull());
+
   // Temporarily go to the variable declaration, read the name.
-  AlternativeReadingScope alt(reader_, kernel_offset);
+  AlternativeReadingScope alt(
+      reader_, &kernel_body,
+      kernel_offset - function_or_parent.kernel_offset());
   VariableDeclarationHelper helper(this);
   helper.ReadUntilIncluding(VariableDeclarationHelper::kNameIndex);
   return helper.name_index_;
 }
 
 FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfStaticFieldInitializer() {
   FieldHelper field_helper(this);
   field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
   ASSERT(field_helper.IsStatic());
 
@@ skipping 169 matching lines @@
   }
 
   Fragment instructions;
   instructions += LoadLocal(scopes()->this_variable);
   instructions += BuildExpression();
   instructions += flow_graph_builder_->StoreInstanceFieldGuarded(field, true);
   return instructions;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildInitializers(
-    intptr_t constructor_class_parent_offset) {
+    const Class& parent_class) {
   Fragment instructions;
 
   // Start by getting the position of the constructors initializer.
   intptr_t initializers_offset = -1;
   {
     AlternativeReadingScope alt(reader_);
     SkipFunctionNode();  // read constructors function node.
     initializers_offset = ReaderOffset();
   }
 
   // These come from:
   //   class A {
   //     var x = (expr);
   //   }
   // We don't want to do that when this is a Redirecting Constructors though
   // (i.e. has a single initializer being of type kRedirectingInitializer).
   bool is_redirecting_constructor = false;
   {
     AlternativeReadingScope alt(reader_, initializers_offset);
     intptr_t list_length = ReadListLength();  // read initializers list length.
     if (list_length == 1) {
       Tag tag = ReadTag();
       if (tag == kRedirectingInitializer) is_redirecting_constructor = true;
     }
   }
 
   if (!is_redirecting_constructor) {
-    AlternativeReadingScope alt(reader_, constructor_class_parent_offset);
-    ClassHelper class_helper(this);
-    class_helper.ReadUntilExcluding(ClassHelper::kFields);
-    intptr_t list_length = ReadListLength();  // read fields list length.
-
-    for (intptr_t i = 0; i < list_length; ++i) {
-      intptr_t field_offset = ReaderOffset();
-      FieldHelper field_helper(this);
-      field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
-      Tag initializer_tag = ReadTag();  // read first part of initializer.
-      if (!field_helper.IsStatic() && initializer_tag == kSomething) {
-        EnterScope(field_offset);
-        instructions += BuildFieldInitializer(
-            field_helper.canonical_name_);  // read initializer.
-        ExitScope(field_offset);
-      } else if (initializer_tag == kSomething) {
-        SkipExpression();  // read initializer.
+    Array& class_fields = Array::Handle(Z, parent_class.fields());
+    dart::Field& class_field = dart::Field::Handle(Z);
+    for (intptr_t i = 0; i < class_fields.Length(); ++i) {
+      class_field ^= class_fields.At(i);
+      if (!class_field.is_static()) {
+        TypedData& kernel_body =
+            TypedData::Handle(Z, class_field.kernel_body());
+        ASSERT(!kernel_body.IsNull());
+        AlternativeReadingScope alt(reader_, &kernel_body, 0);
+        intptr_t saved_relative_kernel_offset_ = relative_kernel_offset_;
+        relative_kernel_offset_ = class_field.kernel_offset();
+        FieldHelper field_helper(this);
+        field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
+        Tag initializer_tag = ReadTag();  // read first part of initializer.
+        if (initializer_tag == kSomething) {
+          EnterScope(class_field.kernel_offset());
+          instructions += BuildFieldInitializer(
+              field_helper.canonical_name_);  // read initializer.
+          ExitScope(class_field.kernel_offset());
+        }
+        relative_kernel_offset_ = saved_relative_kernel_offset_;
       }
     }
   }
 
   // These to come from:
   //   class A {
   //     var x;
   //     var y;
   //     A(this.x) : super(expr), y = (expr);
   //   }
@@ skipping 71 matching lines @@
           //
           //   to
           //
           //      class A {
           //        var x;
           //        A(a, b) : tmp = a + b, x = 2*b, super(tmp) {}
           //      }
           //
           // (This is strictly speaking not what one should do in terms of the
           //  specification but that is how it is currently implemented.)
-          LocalVariable* variable = LookupVariable(ReaderOffset());
+          LocalVariable* variable =
+              LookupVariable(ReaderOffset() + relative_kernel_offset_);
 
           // Variable declaration
           VariableDeclarationHelper helper(this);
           helper.ReadUntilExcluding(VariableDeclarationHelper::kInitializer);
           ASSERT(!helper.IsConst());
           Tag tag = ReadTag();  // read (first part of) initializer.
           if (tag != kSomething) {
             UNREACHABLE();
           }
 
@@ skipping 31 matching lines @@
     body += PushArgument();
   }
 
   FunctionNodeHelper function_node_helper(this);
   function_node_helper.ReadUntilExcluding(
       FunctionNodeHelper::kPositionalParameters);
 
   // Positional.
   intptr_t positional_argument_count = ReadListLength();
   for (intptr_t i = 0; i < positional_argument_count; ++i) {
-    body += LoadLocal(LookupVariable(ReaderOffset()));  // ith variable offset.
+    body += LoadLocal(LookupVariable(
+        ReaderOffset() + relative_kernel_offset_));  // ith variable offset.
     body += PushArgument();
     SkipVariableDeclaration();  // read ith variable.
   }
 
   // Named.
   intptr_t named_argument_count = ReadListLength();
   Array& argument_names = Array::ZoneHandle(Z);
   if (named_argument_count > 0) {
     argument_names = Array::New(named_argument_count);
     for (intptr_t i = 0; i < named_argument_count; ++i) {
       // ith variable offset.
-      body += LoadLocal(LookupVariable(ReaderOffset()));
+      body +=
+          LoadLocal(LookupVariable(ReaderOffset() + relative_kernel_offset_));
       body += PushArgument();
-      StringIndex name = GetNameFromVariableDeclaration(ReaderOffset());
-      argument_names.SetAt(i, H.DartSymbol(name));
-      SkipVariableDeclaration();  // read ith variable.
+
+      // read ith variable.
+      VariableDeclarationHelper helper(this);
+      helper.ReadUntilExcluding(VariableDeclarationHelper::kEnd);
+
+      argument_names.SetAt(i, H.DartSymbol(helper.name_index_));
     }
   }
 
   // Forward them to the target.
   intptr_t argument_count = positional_argument_count + named_argument_count;
   if (!target.is_static()) ++argument_count;
   body += StaticCall(TokenPosition::kNoSource, target, argument_count,
                      argument_names);
 
   // Return the result.
@@ skipping 27 matching lines @@
   function_node_helper.ReadUntilExcluding(
       FunctionNodeHelper::kPositionalParameters);
 
   // Positional.
   const intptr_t positional_argument_count = ReadListLength();
 
   // The first argument is the instance of the closure class.  For converted
   // closures its context field contains the context vector that is used by the
   // converted top-level function (target) explicitly and that should be passed
   // to that function as the first parameter.
-  body += LoadLocal(LookupVariable(ReaderOffset()));  // 0th variable offset.
+  body += LoadLocal(LookupVariable(
+      ReaderOffset() + relative_kernel_offset_));  // 0th variable offset.
   body += flow_graph_builder_->LoadField(Closure::context_offset());
   body += PushArgument();
   SkipVariableDeclaration();  // read 0th variable.
 
   // The rest of the parameters are the same for the method of the Closure class
   // being invoked and the top-level function (target).
   for (intptr_t i = 1; i < positional_argument_count; i++) {
-    body += LoadLocal(LookupVariable(ReaderOffset()));  // ith variable offset.
+    body += LoadLocal(LookupVariable(
+        ReaderOffset() + relative_kernel_offset_));  // ith variable offset.
     body += PushArgument();
     SkipVariableDeclaration();  // read ith variable.
   }
 
   // Named.
   const intptr_t named_argument_count = ReadListLength();
   Array& argument_names = Array::ZoneHandle(Z);
   if (named_argument_count > 0) {
     argument_names = Array::New(named_argument_count);
     for (intptr_t i = 0; i < named_argument_count; i++) {
+      // ith variable offset.
       body +=
-          LoadLocal(LookupVariable(ReaderOffset()));  // ith variable offset.
+          LoadLocal(LookupVariable(ReaderOffset() + relative_kernel_offset_));
       body += PushArgument();
-      argument_names.SetAt(
-          i, H.DartSymbol(GetNameFromVariableDeclaration(ReaderOffset())));
-      SkipVariableDeclaration();  // read ith variable.
+
+      // read ith variable.
+      VariableDeclarationHelper helper(this);
+      helper.ReadUntilExcluding(VariableDeclarationHelper::kEnd);
+
+      argument_names.SetAt(i, H.DartSymbol(helper.name_index_));
     }
   }
 
   // Forward them to the target.
   const intptr_t argument_count =
       positional_argument_count + named_argument_count;
   body += StaticCall(TokenPosition::kNoSource, target, argument_count,
                      argument_names);
 
   // Return the result.
   body += Return(function_node_helper.end_position_);
 
   return new (Z)
       FlowGraph(*parsed_function(), flow_graph_builder_->graph_entry_,
                 flow_graph_builder_->next_block_id_ - 1);
 }
 
-FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfFunction(
-    intptr_t constructor_class_parent_offset) {
+FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfFunction(bool constructor) {
   const Function& dart_function = parsed_function()->function();
   TargetEntryInstr* normal_entry = flow_graph_builder_->BuildTargetEntry();
   flow_graph_builder_->graph_entry_ = new (Z) GraphEntryInstr(
       *parsed_function(), normal_entry, flow_graph_builder_->osr_id_);
 
   SetupDefaultParameterValues();
 
   Fragment body;
   if (!dart_function.is_native())
     body += flow_graph_builder_->CheckStackOverflowInPrologue();
@@ skipping 28 matching lines @@
         body += flow_graph_builder_->StoreInstanceField(
             TokenPosition::kNoSource,
             Context::variable_offset(variable->index()));
         body += NullConstant();
         body += StoreLocal(TokenPosition::kNoSource, parameter);
         body += Drop();
       }
     }
     body += Drop();  // The context.
   }
-  if (constructor_class_parent_offset > 0) {
+  if (constructor) {
     // TODO(27590): Currently the [VariableDeclaration]s from the
     // initializers will be visible inside the entire body of the constructor.
     // We should make a separate scope for them.
-    body += BuildInitializers(constructor_class_parent_offset);
+    body += BuildInitializers(Class::Handle(Z, dart_function.Owner()));
   }
 
   FunctionNodeHelper function_node_helper(this);
   function_node_helper.ReadUntilExcluding(
       FunctionNodeHelper::kPositionalParameters);
   intptr_t first_parameter_offset = -1;
   {
     AlternativeReadingScope alt(reader_);
     intptr_t list_length = ReadListLength();  // read number of positionals.
     if (list_length > 0) {
-      first_parameter_offset = ReaderOffset();
+      first_parameter_offset = ReaderOffset() + relative_kernel_offset_;
     }
   }
   // Current position: About to read list of positionals.
 
   // The specification defines the result of `a == b` to be:
   //
   //   a) if either side is `null` then the result is `identical(a, b)`.
   //   b) else the result is `a.operator==(b)`
   //
   // For user-defined implementations of `operator==` we need therefore
@@ skipping 23 matching lines @@
     body = Fragment(body.entry, non_null_entry);
   }
 
   // If we run in checked mode, we have to check the type of the passed
   // arguments.
   if (I->type_checks()) {
     // Positional.
     intptr_t list_length = ReadListLength();
     for (intptr_t i = 0; i < list_length; ++i) {
       // ith variable offset.
-      body += LoadLocal(LookupVariable(ReaderOffset()));
-      body += CheckVariableTypeInCheckedMode(ReaderOffset());
+      body +=
+          LoadLocal(LookupVariable(ReaderOffset() + relative_kernel_offset_));
+      body += CheckVariableTypeInCheckedMode(ReaderOffset() +
+                                             relative_kernel_offset_);
       body += Drop();
       SkipVariableDeclaration();  // read ith variable.
     }
 
     // Named.
     list_length = ReadListLength();
     for (intptr_t i = 0; i < list_length; ++i) {
       // ith variable offset.
-      body += LoadLocal(LookupVariable(ReaderOffset()));
-      body += CheckVariableTypeInCheckedMode(ReaderOffset());
+      body +=
+          LoadLocal(LookupVariable(ReaderOffset() + relative_kernel_offset_));
+      body += CheckVariableTypeInCheckedMode(ReaderOffset() +
+                                             relative_kernel_offset_);
       body += Drop();
       SkipVariableDeclaration();  // read ith variable.
     }
 
     function_node_helper.SetJustRead(FunctionNodeHelper::kNamedParameters);
   }
 
   function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kBody);
 
   bool has_body = ReadTag() == kSomething;  // read first part of body.
@@ skipping 151 matching lines @@
   // become unreachable after OSR.
   if (flow_graph_builder_->osr_id_ != Compiler::kNoOSRDeoptId) {
     graph_entry->RelinkToOsrEntry(Z, flow_graph_builder_->next_block_id_);
   }
   return new (Z) FlowGraph(*parsed_function(), graph_entry,
                            flow_graph_builder_->next_block_id_ - 1);
 }
 
 FlowGraph* StreamingFlowGraphBuilder::BuildGraph(intptr_t kernel_offset) {
   const Function& function = parsed_function()->function();
+  TypedData& kernel_body = TypedData::Handle(Z, function.kernel_body());
+  if (kernel_body.IsNull() && kernel_offset > 0) {
+    UNREACHABLE();
+  }
 
   // Setup a [ActiveClassScope] and a [ActiveMemberScope] which will be used
   // e.g. for type translation.
   const dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function()->function().Owner());
 
   Function& outermost_function = Function::Handle(Z);
   DiscoverEnclosingElements(Z, function, &outermost_function);
 
   ActiveClassScope active_class_scope(active_class(), &klass);
@@ skipping 14 matching lines @@
     case RawFunction::kConvertedClosureFunction:
     case RawFunction::kRegularFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction: {
       ReadUntilFunctionNode();  // read until function node.
       if (function.IsImplicitClosureFunction()) {
         return BuildGraphOfImplicitClosureFunction(function);
       } else if (function.IsConvertedClosureFunction()) {
         return BuildGraphOfConvertedClosureFunction(function);
       }
-      return BuildGraphOfFunction();
+      return BuildGraphOfFunction(false);
     }
     case RawFunction::kConstructor: {
-      bool is_factory = function.IsFactory();
-      if (is_factory) {
-        ReadUntilFunctionNode();  // read until function node.
-        return BuildGraphOfFunction();
-      } else {
-        // Constructor: Pass offset to parent class.
-        return BuildGraphOfFunction(
-            ReadUntilFunctionNode());  // read until function node.
-      }
+      ReadUntilFunctionNode();  // read until function node.
+      return BuildGraphOfFunction(!function.IsFactory());
     }
     case RawFunction::kImplicitGetter:
     case RawFunction::kImplicitStaticFinalGetter:
     case RawFunction::kImplicitSetter: {
       return IsStaticInitializer(function, Z)
                  ? BuildGraphOfStaticFieldInitializer()
                  : BuildGraphOfFieldAccessor(scopes()->setter_value);
     }
     case RawFunction::kMethodExtractor:
       return flow_graph_builder_->BuildGraphOfMethodExtractor(function);
@@ skipping 2294 matching lines @@
   const dart::Class& map_class =
       dart::Class::Handle(Z, dart::Library::LookupCoreClass(Symbols::Map()));
   const Function& factory_method = Function::ZoneHandle(
       Z, map_class.LookupFactory(
              dart::Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
 
   return instructions + StaticCall(position, factory_method, 2);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildFunctionExpression() {
-  intptr_t offset = ReaderOffset() - 1;  // -1 to include tag byte.
-  return BuildFunctionNode(offset, TokenPosition::kNoSource, false, -1);
+  return BuildFunctionNode(TokenPosition::kNoSource, StringIndex());
 }
 
 Fragment StreamingFlowGraphBuilder::BuildLet(TokenPosition* position) {
   if (position != NULL) *position = TokenPosition::kNoSource;
 
   Fragment instructions = BuildVariableDeclaration();  // read variable.
   instructions += BuildExpression();                   // read body.
   return instructions;
 }
 
@@ skipping 152 matching lines @@
   Fragment instructions = BuildExpression();  // read expression.
   instructions += Drop();
   return instructions;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildBlock() {
   intptr_t offset = ReaderOffset() - 1;  // Include the tag.
 
   Fragment instructions;
 
-  instructions += EnterScope(offset);
+  instructions += EnterScope(offset + relative_kernel_offset_);
   intptr_t list_length = ReadListLength();  // read number of statements.
   for (intptr_t i = 0; i < list_length; ++i) {
     if (instructions.is_open()) {
       instructions += BuildStatement();  // read ith statement.
     } else {
       SkipStatement();  // read ith statement.
     }
   }
-  instructions += ExitScope(offset);
+  instructions += ExitScope(offset + relative_kernel_offset_);
 
   return instructions;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildEmptyStatement() {
   return Fragment();
 }
 
 Fragment StreamingFlowGraphBuilder::BuildAssertStatement() {
   if (!I->asserts()) {
@@ skipping 152 matching lines @@
   return Fragment(new (Z) GotoInstr(join, Thread::Current()->GetNextDeoptId()),
                   loop_exit);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildForStatement() {
   intptr_t offset = ReaderOffset() - 1;  // Include the tag.
 
   Fragment declarations;
 
   bool new_context = false;
-  declarations += EnterScope(offset, &new_context);
+  declarations += EnterScope(offset + relative_kernel_offset_, &new_context);
 
   intptr_t list_length = ReadListLength();  // read number of variables.
   for (intptr_t i = 0; i < list_length; ++i) {
     declarations += BuildVariableDeclaration();  // read ith variable.
   }
 
   loop_depth_inc();
   bool negate = false;
   Tag tag = ReadTag();  // Read first part of condition.
   Fragment condition =
@@ skipping 29 matching lines @@
     Fragment loop(join);
     loop += CheckStackOverflow();
     loop += condition;
   } else {
     declarations += condition;
   }
 
   Fragment loop(declarations.entry, loop_exit);
   loop_depth_dec();
 
-  loop += ExitScope(offset);
+  loop += ExitScope(offset + relative_kernel_offset_);
 
   return loop;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildForInStatement(bool async) {
   intptr_t offset = ReaderOffset() - 1;  // Include the tag.
 
   TokenPosition position = ReadPosition();  // read position.
-  intptr_t variable_kernel_position = ReaderOffset();
+  intptr_t variable_kernel_position = ReaderOffset() + relative_kernel_offset_;
   SkipVariableDeclaration();  // read variable.
 
   TokenPosition iterable_position = TokenPosition::kNoSource;
   Fragment instructions =
       BuildExpression(&iterable_position);  // read iterable.
   instructions += PushArgument();
 
   const dart::String& iterator_getter = dart::String::ZoneHandle(
       Z, dart::Field::GetterSymbol(Symbols::Iterator()));
   instructions +=
       InstanceCall(iterable_position, iterator_getter, Token::kGET, 1);
   LocalVariable* iterator = scopes()->iterator_variables[for_in_depth()];
   instructions += StoreLocal(TokenPosition::kNoSource, iterator);
   instructions += Drop();
 
   for_in_depth_inc();
   loop_depth_inc();
   Fragment condition = LoadLocal(iterator);
   condition += PushArgument();
   condition +=
       InstanceCall(iterable_position, Symbols::MoveNext(), Token::kILLEGAL, 1);
   TargetEntryInstr* body_entry;
   TargetEntryInstr* loop_exit;
   condition += BranchIfTrue(&body_entry, &loop_exit, false);
 
   Fragment body(body_entry);
-  body += EnterScope(offset);
+  body += EnterScope(offset + relative_kernel_offset_);
   body += LoadLocal(iterator);
   body += PushArgument();
   const dart::String& current_getter = dart::String::ZoneHandle(
       Z, dart::Field::GetterSymbol(Symbols::Current()));
   body += InstanceCall(position, current_getter, Token::kGET, 1);
   body += StoreLocal(TokenPosition::kNoSource,
                      LookupVariable(variable_kernel_position));
   body += Drop();
   body += BuildStatement();  // read body.
-  body += ExitScope(offset);
+  body += ExitScope(offset + relative_kernel_offset_);
 
   if (body.is_open()) {
     JoinEntryInstr* join = BuildJoinEntry();
     instructions += Goto(join);
     body += Goto(join);
 
     Fragment loop(join);
     loop += CheckStackOverflow();
     loop += condition;
   } else {
@@ skipping 320 matching lines @@
     Tag tag = PeekTag();                     // peek guard type.
     AbstractType* type_guard = NULL;
     if (tag != kDynamicType) {
       type_guard = &T.BuildType();  // read guard.
       handler_types.SetAt(i, *type_guard);
     } else {
       SkipDartType();  // read guard.
       handler_types.SetAt(i, Object::dynamic_type());
     }
 
-    Fragment catch_handler_body = EnterScope(catch_offset);
+    Fragment catch_handler_body =
+        EnterScope(catch_offset + relative_kernel_offset_);
 
     tag = ReadTag();  // read first part of exception.
     if (tag == kSomething) {
       catch_handler_body += LoadLocal(CurrentException());
       catch_handler_body +=
-          StoreLocal(TokenPosition::kNoSource, LookupVariable(ReaderOffset()));
+          StoreLocal(TokenPosition::kNoSource,
+                     LookupVariable(ReaderOffset() + relative_kernel_offset_));
       catch_handler_body += Drop();
       SkipVariableDeclaration();  // read exception.
     }
 
     tag = ReadTag();  // read first part of stack trace.
     if (tag == kSomething) {
       catch_handler_body += LoadLocal(CurrentStackTrace());
       catch_handler_body +=
-          StoreLocal(TokenPosition::kNoSource, LookupVariable(ReaderOffset()));
+          StoreLocal(TokenPosition::kNoSource,
+                     LookupVariable(ReaderOffset() + relative_kernel_offset_));
       catch_handler_body += Drop();
       SkipVariableDeclaration();  // read stack trace.
     }
 
     {
       CatchBlock block(flow_graph_builder_, CurrentException(),
                        CurrentStackTrace(), try_handler_index);
 
       catch_handler_body += BuildStatement();  // read body.
 
       // Note: ExitScope adjusts context_depth_ so even if catch_handler_body
       // is closed we still need to execute ExitScope for its side effect.
-      catch_handler_body += ExitScope(catch_offset);
+      catch_handler_body += ExitScope(catch_offset + relative_kernel_offset_);
       if (catch_handler_body.is_open()) {
         catch_handler_body += Goto(after_try);
       }
     }
 
     if (type_guard != NULL) {
       if (type_guard->IsMalformed()) {
         catch_body += ThrowTypeError();
         catch_body += Drop();
       } else {
@@ skipping 203 matching lines @@
     rethrow += RethrowException(position, CatchClauseNode::kInvalidTryIndex);
     Drop();
 
     continuation = Fragment(continuation.entry, no_error);
   }
 
   return continuation;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildVariableDeclaration() {
-  intptr_t kernel_position_no_tag = ReaderOffset();
+  intptr_t kernel_position_no_tag = ReaderOffset() + relative_kernel_offset_;
   LocalVariable* variable = LookupVariable(kernel_position_no_tag);
 
   VariableDeclarationHelper helper(this);
   helper.ReadUntilExcluding(VariableDeclarationHelper::kType);
   dart::String& name = H.DartSymbol(helper.name_index_);
   AbstractType& type = T.BuildType();  // read type.
   Tag tag = ReadTag();                 // read (first part of) initializer.
 
   Fragment instructions;
   if (tag == kNothing) {
@@ skipping 18 matching lines @@
       Utils::Maximum(helper.position_, helper.equals_position_);
   if (NeedsDebugStepCheck(stack(), debug_position)) {
     instructions = DebugStepCheck(debug_position) + instructions;
   }
   instructions += StoreLocal(helper.position_, variable);
   instructions += Drop();
   return instructions;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildFunctionDeclaration() {
-  intptr_t offset = ReaderOffset() - 1;     // -1 to include tag byte.
   TokenPosition position = ReadPosition();  // read position.
-  intptr_t variable_offeset = ReaderOffset();
-  SkipVariableDeclaration();  // read variable declaration.
+  intptr_t variable_offset = ReaderOffset() + relative_kernel_offset_;
+
+  // read variable declaration.
+  VariableDeclarationHelper helper(this);
+  helper.ReadUntilExcluding(VariableDeclarationHelper::kEnd);
 
   Fragment instructions = DebugStepCheck(position);
-  instructions += BuildFunctionNode(offset, position, true, variable_offeset);
-  instructions += StoreLocal(position, LookupVariable(variable_offeset));
+  instructions += BuildFunctionNode(position, helper.name_index_);
+  instructions += StoreLocal(position, LookupVariable(variable_offset));
   instructions += Drop();
   return instructions;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildFunctionNode(
-    intptr_t parent_kernel_offset,
     TokenPosition parent_position,
-    bool declaration,
-    intptr_t variable_offeset) {
-  intptr_t offset = ReaderOffset();
+    StringIndex name_index) {
+  intptr_t offset = ReaderOffset() + relative_kernel_offset_;
 
   FunctionNodeHelper function_node_helper(this);
   function_node_helper.ReadUntilExcluding(
       FunctionNodeHelper::kTotalParameterCount);
   TokenPosition position = function_node_helper.position_;
 
+  bool declaration = name_index >= 0;
+
   if (declaration) {
     position = parent_position;
   }
   if (!position.IsReal()) {
     // Positions has to be unique in regards to the parent.
     // A non-real at this point is probably -1, we cannot blindly use that
     // as others might use it too. Create a new dummy non-real TokenPosition.
     position = TokenPosition(offset).ToSynthetic();
   }
 
   // The VM has a per-isolate table of functions indexed by the enclosing
   // function and token position.
   Function& function = Function::ZoneHandle(Z);
 
   // NOTE: This is not TokenPosition in the general sense!
   function = I->LookupClosureFunction(parsed_function()->function(), position);
   if (function.IsNull()) {
     for (intptr_t i = 0; i < scopes()->function_scopes.length(); ++i) {
       if (scopes()->function_scopes[i].kernel_offset != offset) {
         continue;
       }
 
       const dart::String* name;
-      if (!declaration) {
+      if (declaration) {
+        name = &H.DartSymbol(name_index);
+      } else {
         name = &Symbols::AnonymousClosure();
-      } else {
-        name = &H.DartSymbol(GetNameFromVariableDeclaration(variable_offeset));
       }
       // NOTE: This is not TokenPosition in the general sense!
       function = Function::NewClosureFunction(
           *name, parsed_function()->function(), position);
 
       function.set_is_debuggable(function_node_helper.dart_async_marker_ ==
                                  FunctionNode::kSync);
       switch (function_node_helper.dart_async_marker_) {
         case FunctionNode::kSyncStar:
           function.set_modifier(RawFunction::kSyncGen);
@@ skipping 19 matching lines @@
       function.set_end_token_pos(function_node_helper.end_position_);
       LocalScope* scope = scopes()->function_scopes[i].scope;
       const ContextScope& context_scope = ContextScope::Handle(
           Z, scope->PreserveOuterScope(flow_graph_builder_->context_depth_));
       function.set_context_scope(context_scope);
       function.set_kernel_offset(offset);
       SetupFunctionParameters(dart::Class::Handle(Z), function,
                               false,  // is_method
                               true,   // is_closure
                               &function_node_helper);
+      function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
+      TypedData& body_data = reader_->CopyDataToVMHeap(
+          Z, offset - relative_kernel_offset_, ReaderOffset());
+      function.set_kernel_body(body_data);
 
       // Finalize function type.
       Type& signature_type = Type::Handle(Z, function.SignatureType());
       signature_type ^=
           ClassFinalizer::FinalizeType(*active_class()->klass, signature_type);
       function.SetSignatureType(signature_type);
 
       I->AddClosureFunction(function);
       break;
     }
@@ skipping 205 matching lines @@
     Instance& value = constant_evaluator_.EvaluateExpression(ReaderOffset());
     SkipExpression();  // read (actual) initializer.
     metadata_values.SetAt(i, value);
   }
 
   return metadata_values.raw();
 }
 
 void StreamingFlowGraphBuilder::CollectTokenPositionsFor(
     intptr_t script_index,
+    intptr_t initial_script_index,
     GrowableArray<intptr_t>* record_token_positions_in,
     GrowableArray<intptr_t>* record_yield_positions_in) {
   record_token_positions_into_ = record_token_positions_in;
   record_yield_positions_into_ = record_yield_positions_in;
   record_for_script_id_ = script_index;
+  current_script_id_ = initial_script_index;
 
-  // Get offset for 1st library.
-  SetOffset(reader_->size() - 4);
-  intptr_t library_count = reader_->ReadUInt32();
-
-  SetOffset(reader_->size() - 4 - 4 * library_count);
-  intptr_t offset = reader_->ReadUInt32();
-
-  SetOffset(offset);
-  for (intptr_t i = 0; i < library_count; ++i) {
-    LibraryHelper library_helper(this);
-    library_helper.ReadUntilExcluding(LibraryHelper::kEnd);
+  const Tag tag = PeekTag();
+  if (tag == kProcedure) {
+    ProcedureHelper procedure_helper(this);
+    procedure_helper.ReadUntilExcluding(ProcedureHelper::kEnd);
+  } else if (tag == kConstructor) {
+    ConstructorHelper constructor_helper(this);
+    constructor_helper.ReadUntilExcluding(ConstructorHelper::kEnd);
+  } else if (tag == kFunctionNode) {
+    FunctionNodeHelper function_node_helper(this);
+    function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
+  } else if (tag == kField) {
+    FieldHelper field_helper(this);
+    field_helper.ReadUntilExcluding(FieldHelper::kEnd);
+  } else {
+    UNREACHABLE();
   }
 
   record_token_positions_into_ = NULL;
   record_yield_positions_into_ = NULL;
   record_for_script_id_ = -1;
 }
 
 intptr_t StreamingFlowGraphBuilder::SourceTableSize() {
   AlternativeReadingScope alt(reader_);
   SetOffset(reader_->size() - 4);
@@ skipping 14 matching lines @@
   intptr_t end = -1;
   for (intptr_t i = 0; i < size; ++i) {
     intptr_t offset = ReadUInt();
     if (i == index - 1) {
       start = offset;
     } else if (i == index) {
       end = offset;
     }
   }
   intptr_t end_offset = ReaderOffset();
-  return H.DartString(reader_->buffer() + end_offset + start, end - start,
-                      Heap::kOld);
+  return H.DartString(
+      reader_->CopyDataIntoZone(Z, end_offset + start, end - start),
+      end - start, Heap::kOld);
 }
 
 String& StreamingFlowGraphBuilder::GetSourceFor(intptr_t index) {
   AlternativeReadingScope alt(reader_);
   SetOffset(reader_->size() - 4);
   intptr_t library_count = reader_->ReadUInt32();
   SetOffset(reader_->size() - 4 - 4 * library_count - 3 * 4);
   SetOffset(reader_->ReadUInt32());  // read source table offset.
   intptr_t size = ReadUInt();        // read source table size.
   intptr_t uris_size = 0;
   for (intptr_t i = 0; i < size; ++i) {
     uris_size = ReadUInt();
   }
   SkipBytes(uris_size);
 
   // Read the source code strings and line starts.
   for (intptr_t i = 0; i < size; ++i) {
     intptr_t length = ReadUInt();
     if (index == i) {
-      return H.DartString(reader_->buffer() + ReaderOffset(), length,
-                          Heap::kOld);
+      return H.DartString(reader_->CopyDataIntoZone(Z, ReaderOffset(), length),
+                          length, Heap::kOld);
     }
     SkipBytes(length);
     intptr_t line_count = ReadUInt();
     for (intptr_t j = 0; j < line_count; ++j) {
       ReadUInt();
     }
   }
 
   return String::Handle(String::null());
 }
@@ skipping 35 matching lines @@
     }
   }
 
   return Array::Handle(Array::null());
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)