Type Feedback Vector lives in the closure

src/compiler.cc

 // Copyright 2012 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/compiler.h"
 
 #include <algorithm>
 
 #include "src/ast/ast-numbering.h"
 #include "src/ast/prettyprinter.h"
@@ skipping 112 matching lines @@
   if (FLAG_function_context_specialization) MarkAsFunctionContextSpecializing();
   if (FLAG_turbo_inlining) MarkAsInliningEnabled();
   if (FLAG_turbo_source_positions) MarkAsSourcePositionsEnabled();
   if (FLAG_turbo_splitting) MarkAsSplittingEnabled();
   if (FLAG_turbo_types) MarkAsTypingEnabled();
 
   if (has_shared_info()) {
     if (shared_info()->is_compiled()) {
       // We should initialize the CompilationInfo feedback vector from the
       // passed in shared info, rather than creating a new one.
-      feedback_vector_ = Handle<TypeFeedbackVector>(
-          shared_info()->feedback_vector(), parse_info->isolate());
+      feedback_metadata_ = Handle<TypeFeedbackMetadata>(
+          shared_info()->feedback_metadata(), parse_info->isolate());
     }
     if (shared_info()->never_compiled()) MarkAsFirstCompile();
   }
 }
 
 
 CompilationInfo::CompilationInfo(const char* debug_name, Isolate* isolate,
                                  Zone* zone, Code::Flags code_flags)
     : CompilationInfo(nullptr, debug_name, code_flags, STUB, isolate, zone) {}
 
@@ skipping 53 matching lines @@
 // profiler, so they trigger their own optimization when they're called
 // for the SharedFunctionInfo::kCallsUntilPrimitiveOptimization-th time.
 bool CompilationInfo::ShouldSelfOptimize() {
   return FLAG_crankshaft &&
          !(literal()->flags() & AstProperties::kDontSelfOptimize) &&
          !literal()->dont_optimize() &&
          literal()->scope()->AllowsLazyCompilation() &&
          (!has_shared_info() || !shared_info()->optimization_disabled());
 }
 
-
-void CompilationInfo::EnsureFeedbackVector() {
-  if (feedback_vector_.is_null()) {
-    Handle<TypeFeedbackMetadata> feedback_metadata =
+void CompilationInfo::EnsureFeedbackMetadata() {
+  if (feedback_metadata_.is_null()) {
+    feedback_metadata_ =
         TypeFeedbackMetadata::New(isolate(), literal()->feedback_vector_spec());
-    feedback_vector_ = TypeFeedbackVector::New(isolate(), feedback_metadata);
   }
 
   // It's very important that recompiles do not alter the structure of the
   // type feedback vector.
-  CHECK(!feedback_vector_->metadata()->SpecDiffersFrom(
-      literal()->feedback_vector_spec()));
+  CHECK(
+      !feedback_metadata_->SpecDiffersFrom(literal()->feedback_vector_spec()));
 }
 
 
 bool CompilationInfo::has_simple_parameters() {
   return scope()->has_simple_parameters();
 }
 
 
 int CompilationInfo::TraceInlinedFunction(Handle<SharedFunctionInfo> shared,
                                           SourcePosition position,
@@ skipping 146 matching lines @@
       return SetLastStatus(FAILED);
     }
     if (FLAG_hydrogen_stats) {
       isolate()->GetHStatistics()->IncrementFullCodeGen(timer.Elapsed());
     }
   }
 
   DCHECK(info()->shared_info()->has_deoptimization_support());
   DCHECK(!info()->is_first_compile());
 
+  // If we have a closure make sure it has the literals array at this point.
+  if (!info()->closure().is_null()) {
+    JSFunction::EnsureLiterals(info()->closure());
+  }
+
   bool optimization_disabled = info()->shared_info()->optimization_disabled();
   bool dont_crankshaft = info()->shared_info()->dont_crankshaft();
 
   // Check the enabling conditions for Turbofan.
   // 1. "use asm" code.
   bool is_turbofanable_asm = FLAG_turbo_asm &&
                              info()->shared_info()->asm_function() &&
                              !optimization_disabled;
 
   // 2. Fallback for features unsupported by Crankshaft.
@@ skipping 384 matching lines @@
 MUST_USE_RESULT static MaybeHandle<Code> GetUnoptimizedCodeCommon(
     CompilationInfo* info) {
   VMState<COMPILER> state(info->isolate());
   PostponeInterruptsScope postpone(info->isolate());
 
   // Parse and update CompilationInfo with the results.
   if (!Parser::ParseStatic(info->parse_info())) return MaybeHandle<Code>();
   Handle<SharedFunctionInfo> shared = info->shared_info();
   FunctionLiteral* lit = info->literal();
   DCHECK_EQ(shared->language_mode(), lit->language_mode());
+  shared->set_num_literals(lit->materialized_literal_count());
   SetExpectedNofPropertiesFromEstimate(shared, lit->expected_property_count());
   MaybeDisableOptimization(shared, lit->dont_optimize_reason());
 
   // Compile either unoptimized code or bytecode for the interpreter.
   if (!CompileBaselineCode(info)) return MaybeHandle<Code>();
   if (info->code()->kind() == Code::FUNCTION) {  // Only for full code.
     RecordFunctionCompilation(Logger::LAZY_COMPILE_TAG, info, shared);
   }
 
   // Update the shared function info with the scope info. Allocating the
   // ScopeInfo object may cause a GC.
   Handle<ScopeInfo> scope_info =
       ScopeInfo::Create(info->isolate(), info->zone(), info->scope());
   shared->set_scope_info(*scope_info);
 
   // Update the code and feedback vector for the shared function info.
   shared->ReplaceCode(*info->code());
-  shared->set_feedback_vector(*info->feedback_vector());
+  shared->set_feedback_metadata(*info->feedback_metadata());
   if (info->has_bytecode_array()) {
     DCHECK(shared->function_data()->IsUndefined());
     shared->set_function_data(*info->bytecode_array());
   }
 
   return info->code();
 }
 
 
 MUST_USE_RESULT static MaybeHandle<Code> GetCodeFromOptimizedCodeMap(
@@ skipping 193 matching lines @@
     return Handle<Code>(function->shared()->code());
   }
 
   CompilationInfoWithZone info(function);
   Handle<Code> result;
   ASSIGN_RETURN_ON_EXCEPTION(isolate, result, GetUnoptimizedCodeCommon(&info),
                              Code);
 
   if (FLAG_always_opt) {
     Handle<Code> opt_code;
+    JSFunction::EnsureLiterals(function);
     if (Compiler::GetOptimizedCode(function, Compiler::NOT_CONCURRENT)
             .ToHandle(&opt_code)) {
       result = opt_code;
     }
   }
 
   return result;
 }
 
 
 bool Compiler::Compile(Handle<JSFunction> function, ClearExceptionFlag flag) {
   if (function->is_compiled()) return true;
   MaybeHandle<Code> maybe_code = Compiler::GetLazyCode(function);
   Handle<Code> code;
+  Isolate* isolate = function->GetIsolate();
   if (!maybe_code.ToHandle(&code)) {
     if (flag == CLEAR_EXCEPTION) {
-      function->GetIsolate()->clear_pending_exception();
+      isolate->clear_pending_exception();
     }
     return false;
   }
   function->ReplaceCode(*code);
   DCHECK(function->is_compiled());
+  JSFunction::EnsureLiterals(function);
   return true;
 }
 
 
 // TODO(turbofan): In the future, unoptimized code with deopt support could
 // be generated lazily once deopt is triggered.
 bool Compiler::EnsureDeoptimizationSupport(CompilationInfo* info) {
   DCHECK_NOT_NULL(info->literal());
   DCHECK(info->has_scope());
   Handle<SharedFunctionInfo> shared = info->shared_info();
@@ skipping 10 matching lines @@
     // If the current code has reloc info for serialization, also include
     // reloc info for serialization for the new code, so that deopt support
     // can be added without losing IC state.
     if (shared->code()->kind() == Code::FUNCTION &&
         shared->code()->has_reloc_info_for_serialization()) {
       unoptimized.PrepareForSerializing();
     }
     if (!FullCodeGenerator::MakeCode(&unoptimized)) return false;
 
     shared->EnableDeoptimizationSupport(*unoptimized.code());
-    shared->set_feedback_vector(*unoptimized.feedback_vector());
+    shared->set_feedback_metadata(*unoptimized.feedback_metadata());
 
     info->MarkAsCompiled();
 
     // The scope info might not have been set if a lazily compiled
     // function is inlined before being called for the first time.
     if (shared->scope_info() == ScopeInfo::Empty(info->isolate())) {
       Handle<ScopeInfo> target_scope_info =
           ScopeInfo::Create(info->isolate(), info->zone(), info->scope());
       shared->set_scope_info(*target_scope_info);
     }
@@ skipping 55 matching lines @@
 
 static inline bool IsEvalToplevel(Handle<SharedFunctionInfo> shared) {
   return shared->is_toplevel() && shared->script()->IsScript() &&
          Script::cast(shared->script())->compilation_type() ==
              Script::COMPILATION_TYPE_EVAL;
 }
 
 
 bool Compiler::CompileDebugCode(Handle<JSFunction> function) {
   Handle<SharedFunctionInfo> shared(function->shared());
+  bool result;
   if (IsEvalToplevel(shared)) {
-    return CompileEvalForDebugging(function, shared);
+    result = CompileEvalForDebugging(function, shared);
   } else {
     CompilationInfoWithZone info(function);
-    return CompileForDebugging(&info);
+    result = CompileForDebugging(&info);
   }
+  JSFunction::EnsureLiterals(function);
+  return result;
 }
 
 
 bool Compiler::CompileDebugCode(Handle<SharedFunctionInfo> shared) {
   DCHECK(shared->allows_lazy_compilation_without_context());
   DCHECK(!IsEvalToplevel(shared));
   Zone zone;
   ParseInfo parse_info(&zone, shared);
   CompilationInfo info(&parse_info);
   return CompileForDebugging(&info);
@@ skipping 91 matching lines @@
     if (!CompileBaselineCode(info)) {
       return Handle<SharedFunctionInfo>::null();
     }
 
     // Allocate function.
     DCHECK(!info->code().is_null());
     result = isolate->factory()->NewSharedFunctionInfo(
         lit->name(), lit->materialized_literal_count(), lit->kind(),
         info->code(),
         ScopeInfo::Create(info->isolate(), info->zone(), info->scope()),
-        info->feedback_vector());
+        info->feedback_metadata());
     if (info->has_bytecode_array()) {
       DCHECK(result->function_data()->IsUndefined());
       result->set_function_data(*info->bytecode_array());
     }
 
     DCHECK_EQ(RelocInfo::kNoPosition, lit->function_token_position());
     SharedFunctionInfo::InitFromFunctionLiteral(result, lit);
     SharedFunctionInfo::SetScript(result, script);
     result->set_is_toplevel(true);
     if (info->is_eval()) {
@@ skipping 306 matching lines @@
                     !LiveEditFunctionTracker::IsActive(isolate) &&
                     (!info.is_debug() || allow_lazy_without_ctx);
 
   bool lazy = FLAG_lazy && allow_lazy && !literal->should_eager_compile();
 
   // Generate code
   Handle<ScopeInfo> scope_info;
   if (lazy) {
     Handle<Code> code = isolate->builtins()->CompileLazy();
     info.SetCode(code);
-    // There's no need in theory for a lazy-compiled function to have a type
-    // feedback vector, but some parts of the system expect all
-    // SharedFunctionInfo instances to have one.  The size of the vector depends
-    // on how many feedback-needing nodes are in the tree, and when lazily
-    // parsing we might not know that, if this function was never parsed before.
-    // In that case the vector will be replaced the next time MakeCode is
-    // called.
-    info.EnsureFeedbackVector();
+    // There's no need in theory for a lazy-compiled function to have type
+    // feedback metadata, but some parts of the system expect all
+    // SharedFunctionInfo instances to have one.
+    info.EnsureFeedbackMetadata();
     scope_info = Handle<ScopeInfo>(ScopeInfo::Empty(isolate));
   } else if (Renumber(info.parse_info()) && GenerateBaselineCode(&info)) {
     // Code generation will ensure that the feedback vector is present and
     // appropriately sized.
     DCHECK(!info.code().is_null());
     scope_info = ScopeInfo::Create(info.isolate(), info.zone(), info.scope());
     if (literal->should_eager_compile() &&
         literal->should_be_used_once_hint()) {
       info.code()->MarkToBeExecutedOnce(isolate);
     }
   } else {
     return Handle<SharedFunctionInfo>::null();
   }
 
   if (maybe_existing.is_null()) {
     // Create a shared function info object.
     Handle<SharedFunctionInfo> result =
         isolate->factory()->NewSharedFunctionInfo(
             literal->name(), literal->materialized_literal_count(),
-            literal->kind(), info.code(), scope_info, info.feedback_vector());
+            literal->kind(), info.code(), scope_info, info.feedback_metadata());
     if (info.has_bytecode_array()) {
       DCHECK(result->function_data()->IsUndefined());
       result->set_function_data(*info.bytecode_array());
     }
 
     SharedFunctionInfo::InitFromFunctionLiteral(result, literal);
     SharedFunctionInfo::SetScript(result, script);
     result->set_is_toplevel(false);
     // If the outer function has been compiled before, we cannot be sure that
     // shared function info for this function literal has been created for the
     // first time. It may have already been compiled previously.
     result->set_never_compiled(outer_info->is_first_compile() && lazy);
 
     RecordFunctionCompilation(Logger::FUNCTION_TAG, &info, result);
     result->set_allows_lazy_compilation(literal->AllowsLazyCompilation());
     result->set_allows_lazy_compilation_without_context(allow_lazy_without_ctx);
 
     // Set the expected number of properties for instances and return
     // the resulting function.
     SetExpectedNofPropertiesFromEstimate(result,
                                          literal->expected_property_count());
     live_edit_tracker.RecordFunctionInfo(result, literal, info.zone());
     return result;
   } else if (!lazy) {
     // Assert that we are not overwriting (possibly patched) debug code.
     DCHECK(!existing->HasDebugCode());
     existing->ReplaceCode(*info.code());
     existing->set_scope_info(*scope_info);
-    existing->set_feedback_vector(*info.feedback_vector());
+    existing->set_feedback_metadata(*info.feedback_metadata());
   }
   return existing;
 }
 
 Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForNative(
     v8::Extension* extension, Handle<String> name) {
   Isolate* isolate = name->GetIsolate();
   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
 
   // Compute the function template for the native function.
   v8::Local<v8::FunctionTemplate> fun_template =
       extension->GetNativeFunctionTemplate(v8_isolate,
                                            v8::Utils::ToLocal(name));
   DCHECK(!fun_template.IsEmpty());
 
   // Instantiate the function and create a shared function info from it.
   Handle<JSFunction> fun = Handle<JSFunction>::cast(Utils::OpenHandle(
       *fun_template->GetFunction(v8_isolate->GetCurrentContext())
            .ToLocalChecked()));
   const int literals = fun->NumberOfLiterals();
   Handle<Code> code = Handle<Code>(fun->shared()->code());
   Handle<Code> construct_stub = Handle<Code>(fun->shared()->construct_stub());
   Handle<SharedFunctionInfo> shared = isolate->factory()->NewSharedFunctionInfo(
       name, literals, FunctionKind::kNormalFunction, code,
       Handle<ScopeInfo>(fun->shared()->scope_info()),
-      Handle<TypeFeedbackVector>(fun->shared()->feedback_vector()));
+      Handle<TypeFeedbackMetadata>(fun->shared()->feedback_metadata()));
   shared->set_construct_stub(*construct_stub);
 
   // Copy the function data to the shared function info.
   shared->set_function_data(fun->shared()->function_data());
   int parameters = fun->shared()->internal_formal_parameter_count();
   shared->set_internal_formal_parameter_count(parameters);
 
   return shared;
 }
 
@@ skipping 27 matching lines @@
     // The function was never compiled. Compile it unoptimized first.
     // TODO(titzer): reuse the AST and scope info from this compile.
     CompilationInfoWithZone unoptimized(function);
     unoptimized.EnableDeoptimizationSupport();
     if (!GetUnoptimizedCodeCommon(&unoptimized).ToHandle(&current_code)) {
       return MaybeHandle<Code>();
     }
     shared->ReplaceCode(*current_code);
   }
 
+  // At this point we know we've compiled the function, so make sure the closure
+  // points to valid literals and type-feedback-vector.
+  JSFunction::EnsureLiterals(function);
+
   current_code->set_profiler_ticks(0);
 
   // TODO(mstarzinger): We cannot properly deserialize a scope chain containing
   // an eval scope and hence would fail at parsing the eval source again.
   if (shared->disable_optimization_reason() == kEval) {
     return MaybeHandle<Code>();
   }
 
   // TODO(mstarzinger): We cannot properly deserialize a scope chain for the
   // builtin context, hence Genesis::InstallExperimentalNatives would fail.
@@ skipping 104 matching lines @@
 }
 
 #if DEBUG
 void CompilationInfo::PrintAstForTesting() {
   PrintF("--- Source from AST ---\n%s\n",
          PrettyPrinter(isolate()).PrintProgram(literal()));
 }
 #endif
 }  // namespace internal
 }  // namespace v8