[TypeFeedbackVector] Combine the literals array and the feedback vector.

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 <memory>
 #include <sstream>
@@ skipping 10285 matching lines @@
 }
 
 SharedFunctionInfo* DeoptimizationInputData::GetInlinedFunction(int index) {
   if (index == -1) {
     return SharedFunctionInfo::cast(SharedFunctionInfo());
   } else {
     return SharedFunctionInfo::cast(LiteralArray()->get(index));
   }
 }
 
-const int LiteralsArray::kFeedbackVectorOffset =
-    LiteralsArray::OffsetOfElementAt(LiteralsArray::kVectorIndex);
-
-const int LiteralsArray::kOffsetToFirstLiteral =
-    LiteralsArray::OffsetOfElementAt(LiteralsArray::kFirstLiteralIndex);
-
-// static
-Handle<LiteralsArray> LiteralsArray::New(Isolate* isolate,
-                                         Handle<TypeFeedbackVector> vector,
-                                         int number_of_literals,
-                                         PretenureFlag pretenure) {
-  if (vector->is_empty() && number_of_literals == 0) {
-    return Handle<LiteralsArray>::cast(
-        isolate->factory()->empty_literals_array());
-  }
-  Handle<FixedArray> literals = isolate->factory()->NewFixedArray(
-      number_of_literals + kFirstLiteralIndex, pretenure);
-  Handle<LiteralsArray> casted_literals = Handle<LiteralsArray>::cast(literals);
-  casted_literals->set_feedback_vector(*vector);
-  return casted_literals;
-}
-
 int HandlerTable::LookupRange(int pc_offset, int* data_out,
                               CatchPrediction* prediction_out) {
   int innermost_handler = -1;
 #ifdef DEBUG
   // Assuming that ranges are well nested, we don't need to track the innermost
   // offsets. This is just to verify that the table is actually well nested.
   int innermost_start = std::numeric_limits<int>::min();
   int innermost_end = std::numeric_limits<int>::max();
 #endif
   for (int i = 0; i < length(); i += kRangeEntrySize) {
@@ skipping 1704 matching lines @@
       isolate->builtins()->builtin(Builtins::kCompileOptimizedConcurrent));
   // No write barrier required, since the builtin is part of the root set.
   if (FLAG_mark_shared_functions_for_tier_up) {
     // TODO(leszeks): The compilation isn't concurrent if we trigger it using
     // this bit.
     shared()->set_marked_for_tier_up(true);
   }
 }
 
 // static
-Handle<LiteralsArray> SharedFunctionInfo::FindOrCreateLiterals(
+Handle<TypeFeedbackVector> SharedFunctionInfo::FindOrCreateVector(
     Handle<SharedFunctionInfo> shared, Handle<Context> native_context) {
   Isolate* isolate = shared->GetIsolate();
-  CodeAndLiterals result =
+  CodeAndVector result =
       shared->SearchOptimizedCodeMap(*native_context, BailoutId::None());
-  if (result.literals != nullptr) {
+  if (result.vector != nullptr) {
     DCHECK(shared->feedback_metadata()->is_empty() ||
-           !result.literals->feedback_vector()->is_empty());
-    return handle(result.literals, isolate);
+           !result.vector->is_empty());
+    return handle(result.vector, isolate);
   }
 
-  Handle<TypeFeedbackVector> feedback_vector =
+  Handle<TypeFeedbackVector> vector =
       TypeFeedbackVector::New(isolate, handle(shared->feedback_metadata()));
-  Handle<LiteralsArray> literals =
-      LiteralsArray::New(isolate, feedback_vector, shared->num_literals());
   Handle<Code> code;
   if (result.code != nullptr) {
     code = Handle<Code>(result.code, isolate);
   }
-  AddToOptimizedCodeMap(shared, native_context, code, literals,
+  AddToOptimizedCodeMap(shared, native_context, code, vector,
                         BailoutId::None());
-  return literals;
+  return vector;
 }
 
 // static
 void SharedFunctionInfo::AddToOptimizedCodeMap(
     Handle<SharedFunctionInfo> shared, Handle<Context> native_context,
-    MaybeHandle<Code> code, Handle<LiteralsArray> literals,
+    MaybeHandle<Code> code, Handle<TypeFeedbackVector> vector,
     BailoutId osr_ast_id) {
   Isolate* isolate = shared->GetIsolate();
   if (isolate->serializer_enabled()) return;
   DCHECK(code.is_null() ||
          code.ToHandleChecked()->kind() == Code::OPTIMIZED_FUNCTION);
   DCHECK(native_context->IsNativeContext());
   STATIC_ASSERT(kEntryLength == 3);
   Handle<FixedArray> new_code_map;
   int entry;
 
   if (!osr_ast_id.IsNone()) {
-    Context::AddToOptimizedCodeMap(
-        native_context, shared, code.ToHandleChecked(), literals, osr_ast_id);
+    Context::AddToOptimizedCodeMap(native_context, shared,
+                                   code.ToHandleChecked(), vector, osr_ast_id);
     return;
   }
 
   DCHECK(osr_ast_id.IsNone());
   if (shared->OptimizedCodeMapIsCleared()) {
     new_code_map = isolate->factory()->NewFixedArray(kInitialLength, TENURED);
     entry = kEntriesStart;
   } else {
     Handle<FixedArray> old_code_map(shared->optimized_code_map(), isolate);
     entry = shared->SearchOptimizedCodeMapEntry(*native_context);
     if (entry >= kEntriesStart) {
-      // Just set the code and literals of the entry.
+      // Just set the code and vector of the entry.
       if (!code.is_null()) {
         Handle<WeakCell> code_cell =
             isolate->factory()->NewWeakCell(code.ToHandleChecked());
         old_code_map->set(entry + kCachedCodeOffset, *code_cell);
       }
-      Handle<WeakCell> literals_cell =
-          isolate->factory()->NewWeakCell(literals);
-      old_code_map->set(entry + kLiteralsOffset, *literals_cell);
+      Handle<WeakCell> vector_cell = isolate->factory()->NewWeakCell(vector);
+      old_code_map->set(entry + kFeedbackVectorOffset, *vector_cell);
       return;
     }
 
     // Can we reuse an entry?
     DCHECK(entry < kEntriesStart);
     int length = old_code_map->length();
     for (int i = kEntriesStart; i < length; i += kEntryLength) {
       if (WeakCell::cast(old_code_map->get(i + kContextOffset))->cleared()) {
         new_code_map = old_code_map;
         entry = i;
@@ skipping 10 matching lines @@
       // holes. For now we just give up on adding the entry and pretend it got
       // flushed.
       if (shared->OptimizedCodeMapIsCleared()) return;
       entry = old_code_map->length();
     }
   }
 
   Handle<WeakCell> code_cell =
       code.is_null() ? isolate->factory()->empty_weak_cell()
                      : isolate->factory()->NewWeakCell(code.ToHandleChecked());
-  Handle<WeakCell> literals_cell = isolate->factory()->NewWeakCell(literals);
+  Handle<WeakCell> vector_cell = isolate->factory()->NewWeakCell(vector);
   WeakCell* context_cell = native_context->self_weak_cell();
 
   new_code_map->set(entry + kContextOffset, context_cell);
   new_code_map->set(entry + kCachedCodeOffset, *code_cell);
-  new_code_map->set(entry + kLiteralsOffset, *literals_cell);
+  new_code_map->set(entry + kFeedbackVectorOffset, *vector_cell);
 
 #ifdef DEBUG
   for (int i = kEntriesStart; i < new_code_map->length(); i += kEntryLength) {
     WeakCell* cell = WeakCell::cast(new_code_map->get(i + kContextOffset));
     DCHECK(cell->cleared() || cell->value()->IsNativeContext());
     cell = WeakCell::cast(new_code_map->get(i + kCachedCodeOffset));
     DCHECK(cell->cleared() ||
            (cell->value()->IsCode() &&
             Code::cast(cell->value())->kind() == Code::OPTIMIZED_FUNCTION));
-    cell = WeakCell::cast(new_code_map->get(i + kLiteralsOffset));
+    cell = WeakCell::cast(new_code_map->get(i + kFeedbackVectorOffset));
     DCHECK(cell->cleared() || cell->value()->IsFixedArray());
   }
 #endif
 
   FixedArray* old_code_map = shared->optimized_code_map();
   if (old_code_map != *new_code_map) {
     shared->set_optimized_code_map(*new_code_map);
   }
 }
 
@@ skipping 18 matching lines @@
       DCHECK(WeakCell::cast(code_map->get(src))->cleared() ||
              WeakCell::cast(code_map->get(src))->value()->IsNativeContext());
       found = WeakCell::cast(code_map->get(src + kCachedCodeOffset))->value() ==
               optimized_code;
       if (found) {
         if (FLAG_trace_opt) {
           PrintF("[evicting entry from optimizing code map (%s) for ", reason);
           ShortPrint();
           PrintF("]\n");
         }
-        // Just clear the code in order to continue sharing literals.
+        // Just clear the code in order to continue sharing a feedback vector.
         code_map->set(src + kCachedCodeOffset, heap->empty_weak_cell(),
                       SKIP_WRITE_BARRIER);
       }
     }
   }
 
   if (!found) {
     // We didn't find the code in here. It must be osr'd code.
     isolate->EvictOSROptimizedCode(optimized_code, reason);
   }
 }
 
 // static
 void JSFunction::EnsureLiterals(Handle<JSFunction> function) {
   Handle<SharedFunctionInfo> shared(function->shared());
   Handle<Context> native_context(function->context()->native_context());
-  if (function->literals() ==
-      function->GetIsolate()->heap()->empty_literals_array()) {
-    Handle<LiteralsArray> literals =
-        SharedFunctionInfo::FindOrCreateLiterals(shared, native_context);
-    function->set_literals(*literals);
+  if (function->feedback_vector() ==
+      function->GetIsolate()->heap()->empty_type_feedback_vector()) {
+    Handle<TypeFeedbackVector> vector =
+        SharedFunctionInfo::FindOrCreateVector(shared, native_context);
+    function->set_feedback_vector(*vector);
   }
 }
 
 static void GetMinInobjectSlack(Map* map, void* data) {
   int slack = map->unused_property_fields();
   if (*reinterpret_cast<int*>(data) > slack) {
     *reinterpret_cast<int*>(data) = slack;
   }
 }
 
@@ skipping 1559 matching lines @@
     FixedArray* optimized_code_map = this->optimized_code_map();
     int length = optimized_code_map->length();
     WeakCell* empty_weak_cell = GetHeap()->empty_weak_cell();
     for (int i = kEntriesStart; i < length; i += kEntryLength) {
       optimized_code_map->set(i + kCachedCodeOffset, empty_weak_cell,
                               SKIP_WRITE_BARRIER);
     }
   }
 }
 
-CodeAndLiterals SharedFunctionInfo::SearchOptimizedCodeMap(
+CodeAndVector SharedFunctionInfo::SearchOptimizedCodeMap(
     Context* native_context, BailoutId osr_ast_id) {
-  CodeAndLiterals result = {nullptr, nullptr};
+  CodeAndVector result = {nullptr, nullptr};
   if (!osr_ast_id.IsNone()) {
     Code* code;
-    LiteralsArray* literals;
-    native_context->SearchOptimizedCodeMap(this, osr_ast_id, &code, &literals);
-    result = {code, literals};
+    TypeFeedbackVector* vector;
+    native_context->SearchOptimizedCodeMap(this, osr_ast_id, &code, &vector);
+    result = {code, vector};
     return result;
   }
 
   DCHECK(osr_ast_id.IsNone());
   int entry = SearchOptimizedCodeMapEntry(native_context);
   if (entry != kNotFound) {
     FixedArray* code_map = optimized_code_map();
     DCHECK_LE(entry + kEntryLength, code_map->length());
     WeakCell* cell = WeakCell::cast(code_map->get(entry + kCachedCodeOffset));
-    WeakCell* literals_cell =
-        WeakCell::cast(code_map->get(entry + kLiteralsOffset));
+    WeakCell* vector_cell =
+        WeakCell::cast(code_map->get(entry + kFeedbackVectorOffset));
 
     result = {cell->cleared() ? nullptr : Code::cast(cell->value()),
-              literals_cell->cleared() ? nullptr : LiteralsArray::cast(
-                                                       literals_cell->value())};
+              vector_cell->cleared() ? nullptr : TypeFeedbackVector::cast(
+                                                     vector_cell->value())};
   }
   return result;
 }
 
 
 #define DECLARE_TAG(ignore1, name, ignore2) name,
 const char* const VisitorSynchronization::kTags[
     VisitorSynchronization::kNumberOfSyncTags] = {
   VISITOR_SYNCHRONIZATION_TAGS_LIST(DECLARE_TAG)
 };
@@ skipping 6235 matching lines @@
       // depend on this.
       return DICTIONARY_ELEMENTS;
     }
     DCHECK_LE(kind, LAST_ELEMENTS_KIND);
     return kind;
   }
 }
 
 }  // namespace internal
 }  // namespace v8