Back strongly rooted literals CLs out of the tree for branch cut

src/interpreter/bytecode-generator.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/interpreter/bytecode-generator.h"
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/code-stubs.h"
@@ skipping 480 matching lines @@
 
 // Used to build a list of global declaration initial value pairs.
 class BytecodeGenerator::GlobalDeclarationsBuilder final : public ZoneObject {
  public:
   explicit GlobalDeclarationsBuilder(Zone* zone)
       : declarations_(0, zone),
         constant_pool_entry_(0),
         has_constant_pool_entry_(false) {}
 
   void AddFunctionDeclaration(Handle<String> name, FeedbackVectorSlot slot,
-                              FeedbackVectorSlot literal_slot,
                               FunctionLiteral* func) {
     DCHECK(!slot.IsInvalid());
-    declarations_.push_back(Declaration(name, slot, literal_slot, func));
+    declarations_.push_back(Declaration(name, slot, func));
   }
 
   void AddUndefinedDeclaration(Handle<String> name, FeedbackVectorSlot slot) {
     DCHECK(!slot.IsInvalid());
     declarations_.push_back(Declaration(name, slot, nullptr));
   }
 
   Handle<FixedArray> AllocateDeclarations(CompilationInfo* info) {
     DCHECK(has_constant_pool_entry_);
     int array_index = 0;
     Handle<FixedArray> data = info->isolate()->factory()->NewFixedArray(
-        static_cast<int>(declarations_.size() * 4), TENURED);
+        static_cast<int>(declarations_.size() * 3), TENURED);
     for (const Declaration& declaration : declarations_) {
       FunctionLiteral* func = declaration.func;
       Handle<Object> initial_value;
       if (func == nullptr) {
         initial_value = info->isolate()->factory()->undefined_value();
       } else {
         initial_value =
             Compiler::GetSharedFunctionInfo(func, info->script(), info);
       }
 
       // Return a null handle if any initial values can't be created. Caller
       // will set stack overflow.
       if (initial_value.is_null()) return Handle<FixedArray>();
 
       data->set(array_index++, *declaration.name);
       data->set(array_index++, Smi::FromInt(declaration.slot.ToInt()));
-      Object* undefined_or_literal_slot;
-      if (declaration.literal_slot.IsInvalid()) {
-        undefined_or_literal_slot = info->isolate()->heap()->undefined_value();
-      } else {
-        undefined_or_literal_slot =
-            Smi::FromInt(declaration.literal_slot.ToInt());
-      }
-      data->set(array_index++, undefined_or_literal_slot);
       data->set(array_index++, *initial_value);
     }
     return data;
   }
 
   size_t constant_pool_entry() {
     DCHECK(has_constant_pool_entry_);
     return constant_pool_entry_;
   }
 
   void set_constant_pool_entry(size_t constant_pool_entry) {
     DCHECK(!empty());
     DCHECK(!has_constant_pool_entry_);
     constant_pool_entry_ = constant_pool_entry;
     has_constant_pool_entry_ = true;
   }
 
   bool empty() { return declarations_.empty(); }
 
  private:
   struct Declaration {
     Declaration() : slot(FeedbackVectorSlot::Invalid()), func(nullptr) {}
     Declaration(Handle<String> name, FeedbackVectorSlot slot,
-                FeedbackVectorSlot literal_slot, FunctionLiteral* func)
-        : name(name), slot(slot), literal_slot(literal_slot), func(func) {}
-    Declaration(Handle<String> name, FeedbackVectorSlot slot,
                 FunctionLiteral* func)
-        : name(name),
-          slot(slot),
-          literal_slot(FeedbackVectorSlot::Invalid()),
-          func(func) {}
+        : name(name), slot(slot), func(func) {}
 
     Handle<String> name;
     FeedbackVectorSlot slot;
-    FeedbackVectorSlot literal_slot;
     FunctionLiteral* func;
   };
   ZoneVector<Declaration> declarations_;
   size_t constant_pool_entry_;
   bool has_constant_pool_entry_;
 };
 
 BytecodeGenerator::BytecodeGenerator(CompilationInfo* info)
     : zone_(info->zone()),
       builder_(new (zone()) BytecodeArrayBuilder(
@@ skipping 312 matching lines @@
       break;
   }
 }
 
 void BytecodeGenerator::VisitFunctionDeclaration(FunctionDeclaration* decl) {
   Variable* variable = decl->proxy()->var();
   DCHECK(variable->mode() == LET || variable->mode() == VAR);
   switch (variable->location()) {
     case VariableLocation::UNALLOCATED: {
       FeedbackVectorSlot slot = decl->proxy()->VariableFeedbackSlot();
-      globals_builder()->AddFunctionDeclaration(
-          variable->name(), slot, decl->fun()->LiteralFeedbackSlot(),
-          decl->fun());
+      globals_builder()->AddFunctionDeclaration(variable->name(), slot,
+                                                decl->fun());
       break;
     }
     case VariableLocation::PARAMETER:
     case VariableLocation::LOCAL: {
       VisitForAccumulatorValue(decl->fun());
       BuildVariableAssignment(variable, Token::INIT,
                               FeedbackVectorSlot::Invalid(),
                               HoleCheckMode::kElided);
       break;
     }
@@ skipping 2437 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8