Moved type feedback vector to SharedFunctionInfo.

src/compiler.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 123 matching lines @@
   mode_ = mode;
   abort_due_to_dependency_ = false;
   if (script_->type()->value() == Script::TYPE_NATIVE) {
     MarkAsNative();
   }
   if (!shared_info_.is_null()) {
     ASSERT(language_mode() == CLASSIC_MODE);
     SetLanguageMode(shared_info_->language_mode());
   }
   set_bailout_reason(kUnknown);
+
+  if (!shared_info().is_null()) {
+    FixedArray* info_feedback_vector = shared_info()->feedback_vector();
+    if (info_feedback_vector->length() > 0) {
+      // We should initialize the CompilationInfo feedback vector from the
+      // passed in shared info, rather than creating a new one.
+      feedback_vector_ = Handle<FixedArray>(info_feedback_vector, isolate);
+    }
+  }
 }
 
 
 CompilationInfo::~CompilationInfo() {
   delete deferred_handles_;
   delete no_frame_ranges_;
 #ifdef DEBUG
   // Check that no dependent maps have been added or added dependent maps have
   // been rolled back or committed.
   for (int i = 0; i < DependentCode::kGroupCount; i++) {
@@ skipping 89 matching lines @@
       !function()->dont_optimize() &&
       function()->scope()->AllowsLazyCompilation() &&
       (shared_info().is_null() || !shared_info()->optimization_disabled());
 }
 
 
 void CompilationInfo::PrepareForCompilation(Scope* scope) {
   ASSERT(scope_ == NULL);
   scope_ = scope;
   function()->ProcessFeedbackSlots(isolate_);
+  // Allocate the feedback vector too.
+  ASSERT_EQ(isolate()->heap()->the_hole_value(),
+          *TypeFeedbackInfo::UninitializedSentinel(isolate()));

[Benedikt Meurer, 2014/03/05 07:22:56]

Nit: indentation

[mvstanton, 2014/03/05 08:48:02]

Done.

+  int length = function()->slot_count();
+  if (feedback_vector_.is_null()) {
+    feedback_vector_ = isolate()->factory()->NewFixedArrayWithHoles(length,

[Benedikt Meurer, 2014/03/05 07:22:56]

Nit: put arguments on next line.

[mvstanton, 2014/03/05 08:48:02]

Done.

+                                                                    TENURED);
+  }
+  ASSERT(feedback_vector_->length() == length);
 }
 
 
 class HOptimizedGraphBuilderWithPositions: public HOptimizedGraphBuilder {
  public:
   explicit HOptimizedGraphBuilderWithPositions(CompilationInfo* info)
       : HOptimizedGraphBuilder(info) {
   }
 
 #define DEF_VISIT(type)                                 \
@@ skipping 301 matching lines @@
   Handle<SharedFunctionInfo> shared = info->shared_info();
   Handle<ScopeInfo> scope_info =
       ScopeInfo::Create(info->scope(), info->zone());
   shared->set_scope_info(*scope_info);
 
   Handle<Code> code = info->code();
   CHECK(code->kind() == Code::FUNCTION);
   shared->ReplaceCode(*code);
   if (shared->optimization_disabled()) code->set_optimizable(false);
 
+  shared->set_feedback_vector(*(info->feedback_vector()));

[Benedikt Meurer, 2014/03/05 07:22:56]

Nit: *info->feedback_vector()

[mvstanton, 2014/03/05 08:48:02]

Done.

+
   // Set the expected number of properties for instances.
   FunctionLiteral* lit = info->function();
   int expected = lit->expected_property_count();
   SetExpectedNofPropertiesFromEstimate(shared, expected);
 
   // Check the function has compiled code.
   ASSERT(shared->is_compiled());
   shared->set_dont_optimize_reason(lit->dont_optimize_reason());
   shared->set_dont_inline(lit->flags()->Contains(kDontInline));
   shared->set_ast_node_count(lit->ast_node_count());
@@ skipping 235 matching lines @@
       return Handle<SharedFunctionInfo>::null();
     }
 
     // Allocate function.
     ASSERT(!info->code().is_null());
     result = isolate->factory()->NewSharedFunctionInfo(
         lit->name(),
         lit->materialized_literal_count(),
         lit->is_generator(),
         info->code(),
-        ScopeInfo::Create(info->scope(), info->zone()));
+        ScopeInfo::Create(info->scope(), info->zone()),
+        info->feedback_vector());
 
     ASSERT_EQ(RelocInfo::kNoPosition, lit->function_token_position());
     SetFunctionInfo(result, lit, true, script);
 
     Handle<String> script_name = script->name()->IsString()
         ? Handle<String>(String::cast(script->name()))
         : isolate->factory()->empty_string();
     Logger::LogEventsAndTags log_tag = info->is_eval()
         ? Logger::EVAL_TAG
         : Logger::ToNativeByScript(Logger::SCRIPT_TAG, *script);
@@ skipping 190 matching lines @@
   } else {
     return Handle<SharedFunctionInfo>::null();
   }
 
   // Create a shared function info object.
   Handle<SharedFunctionInfo> result =
       factory->NewSharedFunctionInfo(literal->name(),
                                      literal->materialized_literal_count(),
                                      literal->is_generator(),
                                      info.code(),
-                                     scope_info);
+                                     scope_info,
+                                     info.feedback_vector());
   SetFunctionInfo(result, literal, false, script);
   RecordFunctionCompilation(Logger::FUNCTION_TAG, &info, result);
   result->set_allows_lazy_compilation(allow_lazy);
   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());
@@ skipping 260 matching lines @@
   AllowHandleDereference allow_deref;
   bool tracing_on = info()->IsStub()
       ? FLAG_trace_hydrogen_stubs
       : (FLAG_trace_hydrogen &&
          info()->closure()->PassesFilter(FLAG_trace_hydrogen_filter));
   return (tracing_on &&
       OS::StrChr(const_cast<char*>(FLAG_trace_phase), name_[0]) != NULL);
 }
 
 } }  // namespace v8::internal