Add ExternalStringResourceBase::IsCompressible

src/objects.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <sstream>
 
@@ skipping 1669 matching lines @@
   bool is_one_byte = this->IsOneByteRepresentation();
   bool is_internalized = this->IsInternalizedString();
 
   // Morph the string to an external string by replacing the map and
   // reinitializing the fields.  This won't work if the space the existing
   // string occupies is too small for a regular  external string.
   // Instead, we resort to a short external string instead, omitting
   // the field caching the address of the backing store.  When we encounter
   // short external strings in generated code, we need to bailout to runtime.
   Map* new_map;
-  if (size < ExternalString::kSize) {
+  if (size < ExternalString::kSize || resource->isCompressible()) {

[Yang, 2015/12/17 11:41:53]

Is this necessary? For source strings, we always create external strings from
scratch, and do not turn V8 strings into external strings, right? Can we instead
assert that resource is not compressible?

[hajimehoshi, 2016/01/05 08:07:44]

I meant compressible string should use short_*_map to avoid caching in the same
way we did in factory.cc. Am I missing something?

     new_map = is_internalized
         ? (is_one_byte
            ? heap->short_external_internalized_string_with_one_byte_data_map()
            : heap->short_external_internalized_string_map())
         : (is_one_byte ? heap->short_external_string_with_one_byte_data_map()
                        : heap->short_external_string_map());
   } else {
     new_map = is_internalized
         ? (is_one_byte
            ? heap->external_internalized_string_with_one_byte_data_map()
@@ skipping 45 matching lines @@
   Heap* heap = GetHeap();
   bool is_internalized = this->IsInternalizedString();
 
   // Morph the string to an external string by replacing the map and
   // reinitializing the fields.  This won't work if the space the existing
   // string occupies is too small for a regular  external string.
   // Instead, we resort to a short external string instead, omitting
   // the field caching the address of the backing store.  When we encounter
   // short external strings in generated code, we need to bailout to runtime.
   Map* new_map;
-  if (size < ExternalString::kSize) {
+  if (size < ExternalString::kSize || resource->isCompressible()) {
     new_map = is_internalized
                   ? heap->short_external_one_byte_internalized_string_map()
                   : heap->short_external_one_byte_string_map();
   } else {
     new_map = is_internalized
                   ? heap->external_one_byte_internalized_string_map()
                   : heap->external_one_byte_string_map();
   }
 
   // Byte size of the external String object.
@@ skipping 17598 matching lines @@
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 
 }  // namespace internal
 }  // namespace v8