Make line-starts 32-bits TypedData instead of Array of smis.

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 9005 matching lines @@
 RawGrowableObjectArray* Script::GenerateLineNumberArray() const {
   Zone* zone = Thread::Current()->zone();
   const GrowableObjectArray& info =
       GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
   const String& source = String::Handle(zone, Source());
   const String& key = Symbols::Empty();
   const Object& line_separator = Object::Handle(zone);
   Smi& value = Smi::Handle(zone);
 
   if (kind() == RawScript::kKernelTag) {
-    const Array& line_starts_array = Array::Handle(line_starts());
-    if (line_starts_array.IsNull()) {
+    const TypedData& line_starts_data = TypedData::Handle(line_starts());
+    if (line_starts_data.IsNull()) {
       // Scripts in the AOT snapshot do not have a line starts array.
       // A well-formed line number array has a leading null.
       info.Add(line_separator);  // New line.
       return info.raw();
     }
-    intptr_t line_count = line_starts_array.Length();
+    intptr_t line_count = line_starts_data.Length();
     ASSERT(line_count > 0);
     const Array& debug_positions_array = Array::Handle(debug_positions());
     intptr_t token_count = debug_positions_array.Length();
     int token_index = 0;
 
     for (int line_index = 0; line_index < line_count; ++line_index) {
-      value ^= line_starts_array.At(line_index);
-      intptr_t start = value.Value();
+      intptr_t start = line_starts_data.GetUint32(line_index << 2);
       // Output the rest of the tokens if we have no next line.
       intptr_t end = TokenPosition::kMaxSourcePos;
       if (line_index + 1 < line_count) {
-        value ^= line_starts_array.At(line_index + 1);
-        end = value.Value();
+        end = line_starts_data.GetUint32((line_index + 1) << 2);
       }
       bool first = true;
       while (token_index < token_count) {
         value ^= debug_positions_array.At(token_index);
         intptr_t debug_position = value.Value();
         if (debug_position >= end) break;
 
         if (first) {
           info.Add(line_separator);          // New line.
           value = Smi::New(line_index + 1);  // Line number.
@@ skipping 111 matching lines @@
 }
 
 void Script::set_resolved_url(const String& value) const {
   StorePointer(&raw_ptr()->resolved_url_, value.raw());
 }
 
 void Script::set_source(const String& value) const {
   StorePointer(&raw_ptr()->source_, value.raw());
 }
 
-void Script::set_line_starts(const Array& value) const {
+void Script::set_line_starts(const TypedData& value) const {
   StorePointer(&raw_ptr()->line_starts_, value.raw());
 }
 
 void Script::set_debug_positions(const Array& value) const {
   StorePointer(&raw_ptr()->debug_positions_, value.raw());
 }
 
 void Script::set_yield_positions(const Array& value) const {
   StorePointer(&raw_ptr()->yield_positions_, value.raw());
 }
 
 RawArray* Script::yield_positions() const {
 #if !defined(DART_PRECOMPILED_RUNTIME)
   Array& yields = Array::Handle(raw_ptr()->yield_positions_);
   if (yields.IsNull() && kind() == RawScript::kKernelTag) {
     // This is created lazily. Now we need it.
     kernel::CollectTokenPositionsFor(*this);
   }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
   return raw_ptr()->yield_positions_;
 }
 
-RawArray* Script::line_starts() const {
+RawTypedData* Script::line_starts() const {
   return raw_ptr()->line_starts_;
 }
 
 RawArray* Script::debug_positions() const {
 #if !defined(DART_PRECOMPILED_RUNTIME)
   Array& debug_positions_array = Array::Handle(raw_ptr()->debug_positions_);
   if (debug_positions_array.IsNull() && kind() == RawScript::kKernelTag) {
     // This is created lazily. Now we need it.
     kernel::CollectTokenPositionsFor(*this);
   }
@@ skipping 44 matching lines @@
 }
 
 // Specialized for AOT compilation, which does this lookup for every token
 // position that could be part of a stack trace.
 intptr_t Script::GetTokenLineUsingLineStarts(
     TokenPosition target_token_pos) const {
   if (target_token_pos.IsNoSource()) {
     return 0;
   }
   Zone* zone = Thread::Current()->zone();
-  Array& line_starts_array = Array::Handle(zone, line_starts());
-  Smi& token_pos = Smi::Handle(zone);
-  if (line_starts_array.IsNull()) {
+  TypedData& line_starts_data = TypedData::Handle(zone, line_starts());
+  if (line_starts_data.IsNull()) {
     ASSERT(kind() != RawScript::kKernelTag);
-    GrowableObjectArray& line_starts_list =
-        GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
+    GrowableArray<intptr_t> line_starts_list(10);
     const TokenStream& tkns = TokenStream::Handle(zone, tokens());
     TokenStream::Iterator tkit(zone, tkns, TokenPosition::kMinSource,
                                TokenStream::Iterator::kAllTokens);
     intptr_t cur_line = line_offset() + 1;
-    token_pos = Smi::New(0);
+    intptr_t token_pos = 0;
     line_starts_list.Add(token_pos);
     while (tkit.CurrentTokenKind() != Token::kEOS) {
       if (tkit.CurrentTokenKind() == Token::kNEWLINE) {
         cur_line++;
-        token_pos = Smi::New(tkit.CurrentPosition().value() + 1);
+        token_pos = tkit.CurrentPosition().value() + 1;
         line_starts_list.Add(token_pos);
       }
       tkit.Advance();
     }
-    line_starts_array = Array::MakeFixedLength(line_starts_list);
-    set_line_starts(line_starts_array);
+
+    intptr_t length = line_starts_list.length();
+    line_starts_data =
+        TypedData::New(kTypedDataUint32ArrayCid, length, Heap::kOld);
+    for (intptr_t i = 0; i < length; ++i) {
+      line_starts_data.SetUint32(i << 2, line_starts_list.At(i));
+    }
+
+    set_line_starts(line_starts_data);
   }
 
-  ASSERT(line_starts_array.Length() > 0);
+  ASSERT(line_starts_data.Length() > 0);
   intptr_t offset = target_token_pos.Pos();
   intptr_t min = 0;
-  intptr_t max = line_starts_array.Length() - 1;
+  intptr_t max = line_starts_data.Length() - 1;
 
   // Binary search to find the line containing this offset.
   while (min < max) {
     int midpoint = (max - min + 1) / 2 + min;
-    token_pos ^= line_starts_array.At(midpoint);
-    if (token_pos.Value() > offset) {
+    intptr_t value = line_starts_data.GetUint32(midpoint << 2);
+    if (value > offset) {
       max = midpoint - 1;
     } else {
       min = midpoint;
     }
   }
   return min + 1;  // Line numbers start at 1.
 }
 
 void Script::GetTokenLocation(TokenPosition token_pos,
                               intptr_t* line,
                               intptr_t* column,
                               intptr_t* token_len) const {
   ASSERT(line != NULL);
   Zone* zone = Thread::Current()->zone();
 
   if (kind() == RawScript::kKernelTag) {
-    const Array& line_starts_array = Array::Handle(zone, line_starts());
-    if (line_starts_array.IsNull()) {
+    const TypedData& line_starts_data = TypedData::Handle(zone, line_starts());
+    if (line_starts_data.IsNull()) {
       // Scripts in the AOT snapshot do not have a line starts array.
       *line = -1;
       if (column != NULL) {
         *column = -1;
       }
       if (token_len != NULL) {
         *token_len = 1;
       }
       return;
     }
-    ASSERT(line_starts_array.Length() > 0);
+    ASSERT(line_starts_data.Length() > 0);
     intptr_t offset = token_pos.value();
     intptr_t min = 0;
-    intptr_t max = line_starts_array.Length() - 1;
+    intptr_t max = line_starts_data.Length() - 1;
 
     // Binary search to find the line containing this offset.
-    Smi& smi = Smi::Handle(zone);
     while (min < max) {
       intptr_t midpoint = (max - min + 1) / 2 + min;
-
-      smi ^= line_starts_array.At(midpoint);
-      if (smi.Value() > offset) {
+      intptr_t value = line_starts_data.GetUint32(midpoint << 2);
+      if (value > offset) {
         max = midpoint - 1;
       } else {
         min = midpoint;
       }
     }
     *line = min + 1;  // Line numbers start at 1.
-    smi ^= line_starts_array.At(min);
+    intptr_t value = line_starts_data.GetUint32(min << 2);
     if (column != NULL) {
-      *column = offset - smi.Value() + 1;
+      *column = offset - value + 1;
     }
     if (token_len != NULL) {
       // We don't explicitly save this data: Load the source
       // and find it from there.
       const String& source = String::Handle(zone, Source());
       *token_len = 1;
       if (offset < source.Length() &&
           Scanner::IsIdentStartChar(source.CharAt(offset))) {
         for (intptr_t i = offset + 1;
              i < source.Length() && Scanner::IsIdentChar(source.CharAt(i));
@@ skipping 51 matching lines @@
   }
 }
 
 void Script::TokenRangeAtLine(intptr_t line_number,
                               TokenPosition* first_token_index,
                               TokenPosition* last_token_index) const {
   ASSERT(first_token_index != NULL && last_token_index != NULL);
   ASSERT(line_number > 0);
 
   if (kind() == RawScript::kKernelTag) {
-    const Array& line_starts_array = Array::Handle(line_starts());
-    if (line_starts_array.IsNull()) {
+    const TypedData& line_starts_data = TypedData::Handle(line_starts());
+    if (line_starts_data.IsNull()) {
       // Scripts in the AOT snapshot do not have a line starts array.
       *first_token_index = TokenPosition::kNoSource;
       *last_token_index = TokenPosition::kNoSource;
       return;
     }
-    ASSERT(line_starts_array.Length() >= line_number);
-    Smi& value = Smi::Handle();
-    value ^= line_starts_array.At(line_number - 1);
-    *first_token_index = TokenPosition(value.Value());
-    if (line_starts_array.Length() > line_number) {
-      value ^= line_starts_array.At(line_number);
-      *last_token_index = TokenPosition(value.Value() - 1);
+    ASSERT(line_starts_data.Length() >= line_number);
+    intptr_t value = line_starts_data.GetUint32((line_number - 1) << 2);
+    *first_token_index = TokenPosition(value);
+    if (line_starts_data.Length() > line_number) {
+      value = line_starts_data.GetUint32(line_number << 2);
+      *last_token_index = TokenPosition(value - 1);
     } else {
       // Length of source is last possible token in this script.
       *last_token_index = TokenPosition(String::Handle(Source()).Length());
     }
     return;
   }
 
   Zone* zone = Thread::Current()->zone();
   *first_token_index = TokenPosition::kNoSource;
   *last_token_index = TokenPosition::kNoSource;
@@ skipping 13090 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart