Move Kernel strings into the VM's 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/object_store.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
@@ skipping 45 matching lines @@
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
   return dart::Instance::ZoneHandle(Z, result_.raw());
 }
 
 void StreamingConstantEvaluator::EvaluateStaticGet() {
   builder_->ReadPosition();
   int canonical_name_index = builder_->ReadUInt();
   CanonicalName* target = builder_->GetCanonicalName(canonical_name_index);
 
-  if (target->IsField()) {
+  if (H.IsField(target)) {
     const dart::Field& field =
         dart::Field::Handle(Z, H.LookupFieldByKernelField(target));
     if (field.StaticValue() == Object::sentinel().raw() ||
         field.StaticValue() == Object::transition_sentinel().raw()) {
       field.EvaluateInitializer();
       result_ = field.StaticValue();
       result_ = H.Canonicalize(result_);
       field.SetStaticValue(result_, true);
     } else {
       result_ = field.StaticValue();
     }
-  } else if (target->IsProcedure()) {
+  } else if (H.IsProcedure(target)) {
     const Function& function =
         Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
 
-    if (target->IsMethod()) {
+    if (H.IsMethod(target)) {
       Function& closure_function =
           Function::ZoneHandle(Z, function.ImplicitClosureFunction());
       closure_function.set_kernel_function(function.kernel_function());
       result_ = closure_function.ImplicitStaticClosure();
       result_ = H.Canonicalize(result_);
-    } else if (target->IsGetter()) {
+    } else if (H.IsGetter(target)) {
       UNIMPLEMENTED();
     } else {
       UNIMPLEMENTED();
     }
   }
 }
 
 void StreamingConstantEvaluator::EvaluateSymbolLiteral() {
   int str_index = builder_->ReadUInt();
   const dart::String& symbol_value = builder_->DartSymbol(str_index);
@@ skipping 201 matching lines @@
       return BuildBoolLiteral(false);
     case kNullLiteral:
       return BuildNullLiteral();
     default:
       UNREACHABLE();
   }
 
   return Fragment();
 }
 
+
 intptr_t StreamingFlowGraphBuilder::GetStringOffset(intptr_t index) {
   if (string_offsets_ == NULL) {
     intptr_t saved_offset = ReaderOffset();
     reader_->set_offset(4);  // Skip kMagicProgramFile to the string table.
     string_offset_count_ = ReadListLength() + 1;
     string_offsets_ = new intptr_t[string_offset_count_];
 
     // Build a table of the 0-based string start and end offsets.
     string_offsets_[0] = 0;
     for (intptr_t i = 1; i < string_offset_count_; ++i) {
       string_offsets_[i] = ReadUInt();
     }
-    // And adjust the offsets now that we know the start offset of the first
-    // string relative to the start of the binary.
-    intptr_t base = ReaderOffset();
-    for (intptr_t i = 0; i < string_offset_count_; ++i) {
-      string_offsets_[i] += base;
-    }
-
+    // Mark the start of the string data to use for decoding strings.
+    reader_->MarkStringDataOffset();
     SetOffset(saved_offset);
   }
   return string_offsets_[index];
 }
 
+
 CanonicalName* StreamingFlowGraphBuilder::GetCanonicalName(intptr_t index) {
   if (index == 0) return NULL;
   --index;
 
   if (canonical_names_ != NULL && canonical_names_entries_read_ > index) {
     return canonical_names_[index];
   }
 
   intptr_t saved_offset = ReaderOffset();
   if (canonical_names_ == NULL) {
     // Find offset from where to read canonical names table.
 
-    // First skip the string table.  The last offset is the end offset of the
-    // last string.
-    if (string_offsets_ == NULL) {
-      // Ensure that the length and all the offsets are available.
-      GetStringOffset(0);
-    }
-    SetOffset(GetStringOffset(string_offset_count_ - 1));
+    // Skip the magic number.
+    reader_->set_offset(4);
 
-    // There is another string table for the source URIs.  Skip it as well.
+    // Skip the string table.  The last offset is the end offset of the last
+    // string which gives the length of the string data.
     intptr_t list_length = ReadListLength();
     intptr_t end_offset = 0;
     for (intptr_t i = 0; i < list_length; ++i) {
       end_offset = ReadUInt();
     }
     SkipBytes(end_offset);
 
+    // There is another string table for the source URIs.  Skip it as well.
+    list_length = ReadListLength();
+    end_offset = 0;
+    for (intptr_t i = 0; i < list_length; ++i) {
+      end_offset = ReadUInt();
+    }
+    SkipBytes(end_offset);
+
     // Source code table
     for (intptr_t i = 0; i < list_length; ++i) {
       // Source code
       intptr_t bytes = ReadUInt();
       SkipBytes(bytes);
 
       // Line starts table
       intptr_t line_count = ReadUInt();
       for (intptr_t j = 0; j < line_count; ++j) {
         ReadUInt();
@@ skipping 26 matching lines @@
     CanonicalName* canonical_name = parent->AddChild(name);
     canonical_names_[canonical_names_entries_read_] = canonical_name;
   }
 
   canonical_names_next_offset_ = ReaderOffset();
 
   SetOffset(saved_offset);
   return canonical_names_[index];
 }
 
+
 intptr_t StreamingFlowGraphBuilder::ReaderOffset() {
   return reader_->offset();
 }
 
+
 void StreamingFlowGraphBuilder::SetOffset(intptr_t offset) {
   reader_->set_offset(offset);
 }
 
+
 void StreamingFlowGraphBuilder::SkipBytes(intptr_t bytes) {
   reader_->set_offset(ReaderOffset() + bytes);
 }
 
+
 uint32_t StreamingFlowGraphBuilder::ReadUInt() {
   return reader_->ReadUInt();
 }
 
+
 intptr_t StreamingFlowGraphBuilder::ReadListLength() {
   return reader_->ReadListLength();
 }
 
+
 TokenPosition StreamingFlowGraphBuilder::ReadPosition(bool record) {
   return reader_->ReadPosition(record);
 }
 
+
 Tag StreamingFlowGraphBuilder::ReadTag(uint8_t* payload) {
   return reader_->ReadTag(payload);
 }
 
+
 CatchBlock* StreamingFlowGraphBuilder::catch_block() {
   return flow_graph_builder_->catch_block_;
 }
 
+
 ScopeBuildingResult* StreamingFlowGraphBuilder::scopes() {
   return flow_graph_builder_->scopes_;
 }
 
+
 ParsedFunction* StreamingFlowGraphBuilder::parsed_function() {
   return flow_graph_builder_->parsed_function_;
 }
 
+
 dart::String& StreamingFlowGraphBuilder::DartSymbol(intptr_t index) {
   intptr_t start = GetStringOffset(index);
   intptr_t end = GetStringOffset(index + 1);
-  return H.DartSymbol(reader_->buffer() + start, end - start);
+  return H.DartSymbol(reader_->buffer() + reader_->string_data_offset() + start,
+                      end - start);
 }
 
+
 dart::String& StreamingFlowGraphBuilder::DartString(intptr_t index) {
   intptr_t start = GetStringOffset(index);
   intptr_t end = GetStringOffset(index + 1);
-  return H.DartString(reader_->buffer() + start, end - start);
+  return H.DartString(reader_->buffer() + reader_->string_data_offset() + start,
+                      end - start);
 }
 
+
 String* StreamingFlowGraphBuilder::KernelString(intptr_t index) {
   intptr_t start = GetStringOffset(index);
   intptr_t end = GetStringOffset(index + 1);
-  return new String(reader_->buffer() + start, end - start);
+  return new String(start, end - start);
 }
 
+
 Fragment StreamingFlowGraphBuilder::DebugStepCheck(TokenPosition position) {
   return flow_graph_builder_->DebugStepCheck(position);
 }
 
+
 Fragment StreamingFlowGraphBuilder::LoadLocal(LocalVariable* variable) {
   return flow_graph_builder_->LoadLocal(variable);
 }
 
+
 Fragment StreamingFlowGraphBuilder::PushArgument() {
   return flow_graph_builder_->PushArgument();
 }
 
+
 Fragment StreamingFlowGraphBuilder::RethrowException(TokenPosition position,
                                                      int catch_try_index) {
   return flow_graph_builder_->RethrowException(position, catch_try_index);
 }
 
+
 Fragment StreamingFlowGraphBuilder::ThrowNoSuchMethodError() {
   return flow_graph_builder_->ThrowNoSuchMethodError();
 }
 
+
 Fragment StreamingFlowGraphBuilder::Constant(const Object& value) {
   return flow_graph_builder_->Constant(value);
 }
 
+
 Fragment StreamingFlowGraphBuilder::IntConstant(int64_t value) {
   return flow_graph_builder_->IntConstant(value);
 }
 
+
 Fragment StreamingFlowGraphBuilder::LoadStaticField() {
   return flow_graph_builder_->LoadStaticField();
 }
 
+
 Fragment StreamingFlowGraphBuilder::StaticCall(TokenPosition position,
                                                const Function& target,
                                                intptr_t argument_count) {
   return flow_graph_builder_->StaticCall(position, target, argument_count);
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildInvalidExpression() {
   // The frontend will take care of emitting normal errors (like
   // [NoSuchMethodError]s) and only emit [InvalidExpression]s in very special
   // situations (e.g. an invalid annotation).
   return ThrowNoSuchMethodError();
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildStaticGet() {
   intptr_t saved_offset = ReaderOffset() - 1;  // Include the tag.
   TokenPosition position = ReadPosition();
   int canonical_name_index = ReadUInt();
   CanonicalName* target = GetCanonicalName(canonical_name_index);
 
-  if (target->IsField()) {
+  if (H.IsField(target)) {
     const dart::Field& field =
         dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
     if (field.is_const()) {
       SetOffset(saved_offset);  // EvaluateExpression needs the tag.
       return Constant(constant_evaluator_.EvaluateExpression());
     } else {
       const dart::Class& owner = dart::Class::Handle(Z, field.Owner());
       const dart::String& getter_name = H.DartGetterName(target);
       const Function& getter =
           Function::ZoneHandle(Z, owner.LookupStaticFunction(getter_name));
       if (getter.IsNull() || !field.has_initializer()) {
         Fragment instructions = Constant(field);
         return instructions + LoadStaticField();
       } else {
         return StaticCall(position, getter, 0);
       }
     }
   } else {
     const Function& function =
         Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
 
-    if (target->IsGetter()) {
+    if (H.IsGetter(target)) {
       return StaticCall(position, function, 0);
-    } else if (target->IsMethod()) {
+    } else if (H.IsMethod(target)) {
       SetOffset(saved_offset);  // EvaluateExpression needs the tag.
       return Constant(constant_evaluator_.EvaluateExpression());
     } else {
       UNIMPLEMENTED();
     }
   }
 
   return Fragment();
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildSymbolLiteral() {
   SkipBytes(-1);  // EvaluateExpression needs the tag.
   return Constant(constant_evaluator_.EvaluateExpression());
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildThisExpression() {
   return LoadLocal(scopes()->this_variable);
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildRethrow() {
   TokenPosition position = ReadPosition();
   Fragment instructions = DebugStepCheck(position);
   instructions += LoadLocal(catch_block()->exception_var());
   instructions += PushArgument();
   instructions += LoadLocal(catch_block()->stack_trace_var());
   instructions += PushArgument();
   instructions += RethrowException(position, catch_block()->catch_try_index());
 
   return instructions;
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildBigIntLiteral() {
   const dart::String& value = DartString(ReadUInt());
   return Constant(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld)));
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildStringLiteral() {
   intptr_t str_index = ReadUInt();
   return Constant(DartSymbol(str_index));
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildIntLiteral(uint8_t payload) {
   int64_t value = static_cast<int32_t>(payload) - SpecializedIntLiteralBias;
   return IntConstant(value);
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildIntLiteral(bool is_negative) {
   int64_t value = is_negative ? -static_cast<int64_t>(ReadUInt()) : ReadUInt();
   return IntConstant(value);
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildDoubleLiteral() {
   SkipBytes(-1);  // EvaluateExpression needs the tag.
   return Constant(constant_evaluator_.EvaluateExpression());
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildBoolLiteral(bool value) {
   return Constant(Bool::Get(value));
 }
 
+
 Fragment StreamingFlowGraphBuilder::BuildNullLiteral() {
   return Constant(Instance::ZoneHandle(Z, Instance::null()));
 }
 
+
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)