Move the Kernel string offsets 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 75 matching lines @@
       result_ = closure_function.ImplicitStaticClosure();
       result_ = H.Canonicalize(result_);
     } 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);
+  const dart::String& symbol_value = H.DartSymbol(str_index);
 
   const dart::Class& symbol_class =
       dart::Class::ZoneHandle(Z, I->object_store()->symbol_class());
   ASSERT(!symbol_class.IsNull());
   const dart::Function& symbol_constructor = Function::ZoneHandle(
       Z, symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!symbol_constructor.IsNull());
   result_ ^= EvaluateConstConstructorCall(
       symbol_class, TypeArguments::Handle(Z), symbol_constructor, symbol_value);
 }
 
+
 void StreamingConstantEvaluator::EvaluateDoubleLiteral() {
   int str_index = builder_->ReadUInt();
-  result_ = dart::Double::New(builder_->DartString(str_index), Heap::kOld);
+  result_ = dart::Double::New(H.DartString(str_index), Heap::kOld);
   result_ = H.Canonicalize(result_);
 }
 
+
 RawObject* StreamingConstantEvaluator::EvaluateConstConstructorCall(
     const dart::Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     const Object& argument) {
   // Factories have one extra argument: the type arguments.
   // Constructors have 1 extra arguments: receiver.
   const int kNumArgs = 1;
   const int kNumExtraArgs = 1;
   const int num_arguments = kNumArgs + kNumExtraArgs;
@@ skipping 175 matching lines @@
     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();
-    }
-    // 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) {
@@ skipping 47 matching lines @@
       parent = canonical_names_[biased_parent_index - 1];
     } else {
       if (canonical_names_entries_read_ == 0) {
         parent = CanonicalName::NewRoot();
       } else {
         parent = canonical_names_[0]->parent();
       }
     }
     ASSERT(parent != NULL);
     intptr_t name_index = ReadUInt();
-    String* name = KernelString(name_index);
-    CanonicalName* canonical_name = parent->AddChild(name);
+    CanonicalName* canonical_name = parent->AddChild(name_index);
     canonical_names_[canonical_names_entries_read_] = canonical_name;
   }
 
   canonical_names_next_offset_ = ReaderOffset();
 
   SetOffset(saved_offset);
   return canonical_names_[index];
 }
 
 
@@ skipping 40 matching lines @@
 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() + 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() + 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(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);
 }
 
 
@@ skipping 103 matching lines @@
   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());
+  const dart::String& value = H.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));
+  return Constant(H.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) {
@@ skipping 15 matching lines @@
 
 Fragment StreamingFlowGraphBuilder::BuildNullLiteral() {
   return Constant(Instance::ZoneHandle(Z, Instance::null()));
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)