Move the Kernel string offsets into the VM's heap.

runtime/vm/kernel_to_il.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 <set>
-#include <string>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
 #include "vm/kernel_reader.h"
 #include "vm/kernel_binary_flowgraph.h"
 #include "vm/longjump.h"
 #include "vm/method_recognizer.h"
 #include "vm/object_store.h"
@@ skipping 47 matching lines @@
       node_(node),
       translation_helper_(Thread::Current()),
       zone_(translation_helper_.zone()),
       type_translator_(&translation_helper_, &active_class_, /*finalize=*/true),
       current_function_scope_(NULL),
       scope_(NULL),
       depth_(0),
       name_index_(0),
       needs_expr_temp_(false) {
   Script& script = Script::Handle(Z, parsed_function->function().script());
-  H.SetStringData(TypedData::Handle(Z, script.kernel_strings()));
+  H.SetStringOffsets(TypedData::Handle(Z, script.kernel_string_offsets()));
+  H.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
 }
 
 
 void ScopeBuilder::EnterScope(TreeNode* node, TokenPosition start_position) {
   scope_ = new (Z) LocalScope(scope_, depth_.function_, depth_.loop_);
   scope_->set_begin_token_pos(start_position);
   ASSERT(node->kernel_offset() >= 0);
   result_->scopes.Insert(node->kernel_offset(), scope_);
 }
 
@@ skipping 169 matching lines @@
   char name[64];
   OS::SNPrint(name, 64, "%s%" Pd "", prefix, suffix);
   return H.DartSymbol(name);
 }
 
 
 void ScopeBuilder::AddVariable(VariableDeclaration* declaration) {
   // In case `declaration->IsConst()` the flow graph building will take care of
   // evaluating the constant and setting it via
   // `declaration->SetConstantValue()`.
-  const dart::String& name = declaration->name()->is_empty()
+  const dart::String& name = (H.StringSize(declaration->name()) == 0)
                                  ? GenerateName(":var", name_index_++)
                                  : H.DartSymbol(declaration->name());
   LocalVariable* variable =
       MakeVariable(declaration->position(), declaration->end_position(), name,
                    T.TranslateVariableType(declaration));
   if (declaration->IsFinal()) {
     variable->set_is_final();
   }
   scope_->AddVariable(variable);
   result_->locals.Insert(declaration->kernel_offset(), variable);
@@ skipping 761 matching lines @@
   result <<= next;
   return result;
 }
 
 
 TranslationHelper::TranslationHelper(dart::Thread* thread)
     : thread_(thread),
       zone_(thread->zone()),
       isolate_(thread->isolate()),
       allocation_space_(thread->IsMutatorThread() ? Heap::kNew : Heap::kOld),
-      string_data_(TypedData::Handle(zone_)) {}
+      string_offsets_(TypedData::Handle(Z)),
+      string_data_(TypedData::Handle(Z)) {}
+
+
+void TranslationHelper::SetStringOffsets(const TypedData& string_offsets) {
+  ASSERT(string_offsets_.IsNull());
+  string_offsets_ = string_offsets.raw();
+}
 
 
 void TranslationHelper::SetStringData(const TypedData& string_data) {
   ASSERT(string_data_.IsNull());
   string_data_ = string_data.raw();
 }
 
 
-uint8_t TranslationHelper::CharacterAt(String* string, intptr_t index) {
-  ASSERT(index < string->size());
-  return string_data_.GetUint8(string->offset() + index);
+intptr_t TranslationHelper::StringOffset(intptr_t string_index) const {
+  return string_offsets_.GetUint32(string_index << 2);
 }
 
 
-bool TranslationHelper::StringEquals(String* string, const char* other) {
+intptr_t TranslationHelper::StringSize(intptr_t string_index) const {
+  return StringOffset(string_index + 1) - StringOffset(string_index);
+}
+
+
+uint8_t TranslationHelper::CharacterAt(intptr_t string_index, intptr_t index) {
+  ASSERT(index < StringSize(string_index));
+  return string_data_.GetUint8(StringOffset(string_index) + index);
+}
+
+
+bool TranslationHelper::StringEquals(intptr_t string_index, const char* other) {
   NoSafepointScope no_safepoint;
   intptr_t length = strlen(other);
-  return (length == string->size()) &&
-         memcmp(string_data_.DataAddr(string->offset()), other, length) == 0;
+  return (length == StringSize(string_index)) &&
+         (memcmp(string_data_.DataAddr(StringOffset(string_index)), other,
+                 length) == 0);
 }
 
 
 bool TranslationHelper::IsAdministrative(CanonicalName* name) {
   // Administrative names start with '@'.
-  return (name->name()->size() > 0) && (CharacterAt(name->name(), 0) == '@');
+  return (StringSize(name->name()) > 0) &&
+         (CharacterAt(name->name(), 0) == '@');
 }
 
 
 bool TranslationHelper::IsPrivate(CanonicalName* name) {
   // Private names start with '_'.
-  return (name->name()->size() > 0) && (CharacterAt(name->name(), 0) == '_');
+  return (StringSize(name->name()) > 0) &&
+         (CharacterAt(name->name(), 0) == '_');
 }
 
 
 bool TranslationHelper::IsRoot(CanonicalName* name) {
   // The root is the only canonical name with no parent.
   return name->parent() == NULL;
 }
 
 
 bool TranslationHelper::IsLibrary(CanonicalName* name) {
@@ skipping 133 matching lines @@
   return result;
 }
 
 
 const dart::String& TranslationHelper::DartString(const char* content,
                                                   Heap::Space space) {
   return dart::String::ZoneHandle(Z, dart::String::New(content, space));
 }
 
 
-dart::String& TranslationHelper::DartString(String* content,
+dart::String& TranslationHelper::DartString(intptr_t string_index,
                                             Heap::Space space) {
-  intptr_t length = content->size();
+  intptr_t length = StringSize(string_index);
   uint8_t* buffer = Z->Alloc<uint8_t>(length);
   {
     NoSafepointScope no_safepoint;
-    memmove(buffer, string_data_.DataAddr(content->offset()), length);
+    memmove(buffer, string_data_.DataAddr(StringOffset(string_index)), length);
   }
   return dart::String::ZoneHandle(
       Z, dart::String::FromUTF8(buffer, length, space));
 }
 
 
 dart::String& TranslationHelper::DartString(const uint8_t* utf8_array,
                                             intptr_t len,
                                             Heap::Space space) {
   return dart::String::ZoneHandle(
       Z, dart::String::FromUTF8(utf8_array, len, space));
 }
 
 
 const dart::String& TranslationHelper::DartSymbol(const char* content) const {
   return dart::String::ZoneHandle(Z, Symbols::New(thread_, content));
 }
 
 
-dart::String& TranslationHelper::DartSymbol(String* content) const {
-  intptr_t length = content->size();
+dart::String& TranslationHelper::DartSymbol(intptr_t string_index) const {
+  intptr_t length = StringSize(string_index);
   uint8_t* buffer = Z->Alloc<uint8_t>(length);
   {
     NoSafepointScope no_safepoint;
-    memmove(buffer, string_data_.DataAddr(content->offset()), length);
+    memmove(buffer, string_data_.DataAddr(StringOffset(string_index)), length);
   }
   return dart::String::ZoneHandle(
       Z, dart::Symbols::FromUTF8(thread_, buffer, length));
 }
 
 dart::String& TranslationHelper::DartSymbol(const uint8_t* utf8_array,
                                             intptr_t len) const {
   return dart::String::ZoneHandle(
       Z, dart::Symbols::FromUTF8(thread_, utf8_array, len));
 }
@@ skipping 27 matching lines @@
   }
 }
 
 
 const dart::String& TranslationHelper::DartSetterName(CanonicalName* setter) {
   return DartSetterName(setter->parent(), setter->name());
 }
 
 
 const dart::String& TranslationHelper::DartSetterName(Name* setter_name) {
-  return DartSetterName(setter_name->library(), setter_name->string());
+  return DartSetterName(setter_name->library(), setter_name->string_index());
 }
 
 
 const dart::String& TranslationHelper::DartSetterName(CanonicalName* parent,
-                                                      String* setter) {
+                                                      intptr_t setter) {
   // The names flowing into [setter] are coming from the Kernel file:
   //   * user-defined setters: `fieldname=`
   //   * property-set expressions:  `fieldname`
   //
   // The VM uses `get:fieldname` and `set:fieldname`.
   //
   // => In order to be consistent, we remove the `=` always and adopt the VM
   //    conventions.
-  ASSERT(setter->size() > 0);
-  intptr_t skip = 0;
-  if (CharacterAt(setter, setter->size() - 1) == '=') {
-    skip = 1;
+  intptr_t size = StringSize(setter);
+  ASSERT(size > 0);
+  if (CharacterAt(setter, size - 1) == '=') {
+    --size;
   }
-  intptr_t length = setter->size() - skip;
-  uint8_t* buffer = Z->Alloc<uint8_t>(length);
+  uint8_t* buffer = Z->Alloc<uint8_t>(size);
   {
     NoSafepointScope no_safepoint;
-    memmove(buffer, string_data_.DataAddr(setter->offset()), length);
+    memmove(buffer, string_data_.DataAddr(StringOffset(setter)), size);
   }
   dart::String& name = dart::String::ZoneHandle(
-      Z, dart::String::FromUTF8(buffer, length, allocation_space_));
+      Z, dart::String::FromUTF8(buffer, size, allocation_space_));
   ManglePrivateName(parent, &name, false);
   name = dart::Field::SetterSymbol(name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartGetterName(CanonicalName* getter) {
   return DartGetterName(getter->parent(), getter->name());
 }
 
 
 const dart::String& TranslationHelper::DartGetterName(Name* getter_name) {
-  return DartGetterName(getter_name->library(), getter_name->string());
+  return DartGetterName(getter_name->library(), getter_name->string_index());
 }
 
 
 const dart::String& TranslationHelper::DartGetterName(CanonicalName* parent,
-                                                      String* getter) {
+                                                      intptr_t getter) {
   dart::String& name = DartString(getter);
   ManglePrivateName(parent, &name, false);
   name = dart::Field::GetterSymbol(name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartFieldName(Name* kernel_name) {
-  dart::String& name = DartString(kernel_name->string());
+  dart::String& name = DartString(kernel_name->string_index());
   return ManglePrivateName(kernel_name->library(), &name);
 }
 
 
 const dart::String& TranslationHelper::DartInitializerName(Name* kernel_name) {
   // The [DartFieldName] will take care of mangling the name.
   dart::String& name =
       dart::String::Handle(Z, DartFieldName(kernel_name).raw());
   name = Symbols::FromConcat(thread_, Symbols::InitPrefix(), name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartMethodName(CanonicalName* method) {
   return DartMethodName(method->parent(), method->name());
 }
 
 
 const dart::String& TranslationHelper::DartMethodName(Name* method_name) {
-  return DartMethodName(method_name->library(), method_name->string());
+  return DartMethodName(method_name->library(), method_name->string_index());
 }
 
 
 const dart::String& TranslationHelper::DartMethodName(CanonicalName* parent,
-                                                      String* method) {
+                                                      intptr_t method) {
   dart::String& name = DartString(method);
   return ManglePrivateName(parent, &name);
 }
 
 
 const dart::String& TranslationHelper::DartFactoryName(CanonicalName* factory) {
   ASSERT(IsConstructor(factory) || IsFactory(factory));
   GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
   pieces.Add(DartClassName(EnclosingName(factory)));
   pieces.Add(Symbols::Dot());
@@ skipping 651 matching lines @@
   }
 }
 
 
 void ConstantEvaluator::VisitNot(Not* node) {
   result_ ^= Bool::Get(!EvaluateBooleanExpression(node->expression())).raw();
 }
 
 
 void ConstantEvaluator::VisitPropertyGet(PropertyGet* node) {
-  const intptr_t kLengthLen = sizeof("length") - 1;
-
-  String* string = node->name()->string();
-  if ((string->size() == kLengthLen) && H.StringEquals(string, "length")) {
+  intptr_t string_index = node->name()->string_index();
+  if (H.StringEquals(string_index, "length")) {
     node->receiver()->AcceptExpressionVisitor(this);
     if (result_.IsString()) {
       const dart::String& str =
           dart::String::Handle(Z, dart::String::RawCast(result_.raw()));
       result_ = Integer::New(str.Length());
     } else {
       H.ReportError(
           "Constant expressions can only call "
           "'length' on string constants.");
     }
@@ skipping 106 matching lines @@
       try_finally_block_(NULL),
       try_catch_block_(NULL),
       next_used_try_index_(0),
       catch_block_(NULL),
       type_translator_(&translation_helper_,
                        &active_class_,
                        /* finalize= */ true),
       constant_evaluator_(this, zone_, &translation_helper_, &type_translator_),
       streaming_flow_graph_builder_(NULL) {
   Script& script = Script::Handle(Z, parsed_function->function().script());
-  H.SetStringData(TypedData::Handle(Z, script.kernel_strings()));
+  H.SetStringOffsets(TypedData::Handle(Z, script.kernel_string_offsets()));
+  H.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
 }
 
 
 FlowGraphBuilder::~FlowGraphBuilder() {
   if (streaming_flow_graph_builder_ != NULL) {
     delete streaming_flow_graph_builder_;
   }
 }
 
 
@@ skipping 2474 matching lines @@
   pos++;
   for (intptr_t i = 0; i < positional_count; i++, pos++) {
     node->positional_parameters()[i]->AcceptDartTypeVisitor(this);
     if (result_.IsMalformed()) {
       result_ = AbstractType::dynamic_type().raw();
     }
     parameter_types.SetAt(pos, result_);
     parameter_names.SetAt(pos, H.DartSymbol("noname"));
   }
   for (intptr_t i = 0; i < named_count; i++, pos++) {
-    Tuple<String, DartType>* tuple = node->named_parameters()[i];
-    tuple->second()->AcceptDartTypeVisitor(this);
+    NamedParameter* parameter = node->named_parameters()[i];
+    parameter->type()->AcceptDartTypeVisitor(this);
     if (result_.IsMalformed()) {
       result_ = AbstractType::dynamic_type().raw();
     }
     parameter_types.SetAt(pos, result_);
-    parameter_names.SetAt(pos, H.DartSymbol(tuple->first()));
+    parameter_names.SetAt(pos, H.DartSymbol(parameter->name()));
   }
 
   Type& signature_type =
       Type::ZoneHandle(Z, signature_function.SignatureType());
 
   if (finalize_) {
     signature_type ^=
         ClassFinalizer::FinalizeType(*active_class_->klass, signature_type);
     // Do not refer to signature_function anymore, since it may have been
     // replaced during canonicalization.
@@ skipping 2024 matching lines @@
       metadata_expressions = &Field::Cast(kernel_node)->annotations();
     } else if (kernel_node->IsConstructor()) {
       metadata_expressions = &Constructor::Cast(kernel_node)->annotations();
     } else {
       FATAL1("No support for metadata on this type of kernel node %p\n",
              kernel_node);
     }
 
     TranslationHelper helper(thread);
     Script& script = Script::Handle(Z, metadata_field.Script());
-    helper.SetStringData(TypedData::Handle(Z, script.kernel_strings()));
+    helper.SetStringOffsets(
+        TypedData::Handle(Z, script.kernel_string_offsets()));
+    helper.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
     DartTypeTranslator type_translator(&helper, NULL, true);
     ConstantEvaluator constant_evaluator(/* flow_graph_builder = */ NULL, Z,
                                          &helper, &type_translator);
 
     const Array& metadata_values =
         Array::Handle(Z, Array::New(metadata_expressions->length()));
 
     for (intptr_t i = 0; i < metadata_expressions->length(); i++) {
       const Instance& value =
           constant_evaluator.EvaluateExpression((*metadata_expressions)[i]);
@@ skipping 76 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)