Avoid triggering an ASSERT in TypedData

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 "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 118 matching lines @@
 intptr_t TranslationHelper::StringSize(StringIndex index) const {
   return StringOffset(StringIndex(index + 1)) - StringOffset(index);
 }
 
 uint8_t TranslationHelper::CharacterAt(StringIndex string_index,
                                        intptr_t index) {
   ASSERT(index < StringSize(string_index));
   return string_data_.GetUint8(StringOffset(string_index) + index);
 }
 
+uint8_t* TranslationHelper::StringBuffer(StringIndex string_index) const {
+  // Though this implementation appears like it could be replaced by
+  // string_data_.DataAddr(StringOffset(string_index)), it can't quite.  If the
+  // last string in the string table is a zero length string, then the latter
+  // expression will try to return the address that is one past the backing
+  // store of the string_data_ table.  Though this is safe in C++ as long as the
+  // address is not dereferenced, it will trigger the assert in
+  // TypedData::DataAddr.
+  ASSERT(Thread::Current()->no_safepoint_scope_depth() > 0);
+  return reinterpret_cast<uint8_t*>(string_data_.DataAddr(0)) +
+         StringOffset(string_index);
+}
+
 bool TranslationHelper::StringEquals(StringIndex string_index,
                                      const char* other) {
+  intptr_t length = strlen(other);
+  if (length != StringSize(string_index)) return false;
+
   NoSafepointScope no_safepoint;
-  intptr_t length = strlen(other);
-  return (length == StringSize(string_index)) &&
-         (memcmp(string_data_.DataAddr(StringOffset(string_index)), other,
-                 length) == 0);
+  return memcmp(StringBuffer(string_index), other, length) == 0;
 }
 
 NameIndex TranslationHelper::CanonicalNameParent(NameIndex name) {
   // Canonical names are pairs of 4-byte parent and string indexes, so the size
   // of an entry is 8 bytes.  The parent is biased: 0 represents the root name
   // and N+1 represents the name with index N.
   return NameIndex(static_cast<intptr_t>(canonical_names_.GetUint32(8 * name)) -
                    1);
 }
 
@@ skipping 148 matching lines @@
                                             Heap::Space space) {
   return String::ZoneHandle(Z, String::New(content, space));
 }
 
 String& TranslationHelper::DartString(StringIndex string_index,
                                       Heap::Space space) {
   intptr_t length = StringSize(string_index);
   uint8_t* buffer = Z->Alloc<uint8_t>(length);
   {
     NoSafepointScope no_safepoint;
-    memmove(buffer, string_data_.DataAddr(StringOffset(string_index)), length);
+    memmove(buffer, StringBuffer(string_index), length);
   }
   return String::ZoneHandle(Z, String::FromUTF8(buffer, length, space));
 }
 
 String& TranslationHelper::DartString(const uint8_t* utf8_array,
                                       intptr_t len,
                                       Heap::Space space) {
   return String::ZoneHandle(Z, String::FromUTF8(utf8_array, len, space));
 }
 
 const String& TranslationHelper::DartSymbol(const char* content) const {
   return String::ZoneHandle(Z, Symbols::New(thread_, content));
 }
 
 String& TranslationHelper::DartSymbol(StringIndex 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(StringOffset(string_index)), length);
+    memmove(buffer, StringBuffer(string_index), length);
   }
   return String::ZoneHandle(Z, Symbols::FromUTF8(thread_, buffer, length));
 }
 
 String& TranslationHelper::DartSymbol(const uint8_t* utf8_array,
                                       intptr_t len) const {
   return String::ZoneHandle(Z, Symbols::FromUTF8(thread_, utf8_array, len));
 }
 
 const String& TranslationHelper::DartClassName(NameIndex kernel_class) {
@@ skipping 36 matching lines @@
   // => In order to be consistent, we remove the `=` always and adopt the VM
   //    conventions.
   intptr_t size = StringSize(setter);
   ASSERT(size > 0);
   if (CharacterAt(setter, size - 1) == '=') {
     --size;
   }
   uint8_t* buffer = Z->Alloc<uint8_t>(size);
   {
     NoSafepointScope no_safepoint;
-    memmove(buffer, string_data_.DataAddr(StringOffset(setter)), size);
+    memmove(buffer, StringBuffer(setter), size);
   }
   String& name =
       String::ZoneHandle(Z, String::FromUTF8(buffer, size, allocation_space_));
   ManglePrivateName(parent, &name, false);
   name = Field::SetterSymbol(name);
   return name;
 }
 
 const String& TranslationHelper::DartGetterName(NameIndex getter) {
   return DartGetterName(CanonicalNameParent(getter),
@@ skipping 1999 matching lines @@
   array_object = AsSortedDuplicateFreeArray(&token_positions);
   script.set_debug_positions(array_object);
   array_object = AsSortedDuplicateFreeArray(&yield_positions);
   script.set_yield_positions(array_object);
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)