Adding a type vector to replace type cells.

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 225 matching lines @@
 // for the SharedFunctionInfo::kCallsUntilPrimitiveOptimization-th time.
 bool CompilationInfo::ShouldSelfOptimize() {
   return FLAG_crankshaft &&
       !function()->flags()->Contains(kDontSelfOptimize) &&
       !function()->dont_optimize() &&
       function()->scope()->AllowsLazyCompilation() &&
       (shared_info().is_null() || !shared_info()->optimization_disabled());
 }
 
 
+void CompilationInfo::ProcessFeedbackSlots() {

[Benedikt Meurer, 2014/02/04 08:53:50]

Why is this in CompilationInfo? And why do we need three different call sites
for this in the pipeline?

[mvstanton, 2014/02/04 13:03:27]

I managed to reduce this to a single chokepoint, SetScope(), now renamed
InitializeScope().

+  // Scope analysis must have been done.

[Benedikt Meurer, 2014/02/04 08:53:50]

Can we ASSERT that?

[mvstanton, 2014/02/04 13:03:27]

It's enough to do the work in InitializeScope() now, after the scope has been
set. I couldn't find a good handle on Scope to make sure it's complete. There is
a predicate, already_resolved(), but it doesn't appear to do exactly what I need
(private to Scope).

+  function()->ProcessFeedbackSlots(isolate_);
+}
+
+
 class HOptimizedGraphBuilderWithPositions: public HOptimizedGraphBuilder {
  public:
   explicit HOptimizedGraphBuilderWithPositions(CompilationInfo* info)
       : HOptimizedGraphBuilder(info) {
   }
 
 #define DEF_VISIT(type)                                 \
   virtual void Visit##type(type* node) V8_OVERRIDE {    \
     if (node->position() != RelocInfo::kNoPosition) {   \
       SetSourcePosition(node->position());              \
@@ skipping 350 matching lines @@
   function_info->set_dont_cache(lit->flags()->Contains(kDontCache));
   function_info->set_is_generator(lit->is_generator());
 }
 
 
 static bool CompileUnoptimizedCode(CompilationInfo* info) {
   ASSERT(info->function() != NULL);
   if (!Rewriter::Rewrite(info)) return false;
   if (!Scope::Analyze(info)) return false;
   ASSERT(info->scope() != NULL);
+  info->ProcessFeedbackSlots();
 
   if (!FullCodeGenerator::MakeCode(info)) {
     Isolate* isolate = info->isolate();
     if (!isolate->has_pending_exception()) isolate->StackOverflow();
     return false;
   }
   return true;
 }
 
 
@@ skipping 345 matching lines @@
   } else if (result->ic_age() != isolate->heap()->global_ic_age()) {
       result->ResetForNewContext(isolate->heap()->global_ic_age());
   }
 
   if (result.is_null()) isolate->ReportPendingMessages();
   return result;
 }
 
 
 Handle<SharedFunctionInfo> Compiler::BuildFunctionInfo(FunctionLiteral* literal,
-                                                       Handle<Script> script) {
+                                                       Handle<Script> script,
+                                                       bool process_feedback) {
   // Precondition: code has been parsed and scopes have been analyzed.
   CompilationInfoWithZone info(script);
   info.SetFunction(literal);
   info.SetScope(literal->scope());
+  if (process_feedback) {
+    info.ProcessFeedbackSlots();
+  }
   info.SetLanguageMode(literal->scope()->language_mode());
 
   Isolate* isolate = info.isolate();
   Factory* factory = isolate->factory();
   LiveEditFunctionTracker live_edit_tracker(isolate, literal);
   // Determine if the function can be lazily compiled. This is necessary to
   // allow some of our builtin JS files to be lazily compiled. These
   // builtins cannot be handled lazily by the parser, since we have to know
   // if a function uses the special natives syntax, which is something the
   // parser records.
@@ skipping 80 matching lines @@
 }
 
 
 static bool CompileOptimizedPrologue(CompilationInfo* info) {
   if (!Parser::Parse(info)) return false;
   LanguageMode language_mode = info->function()->language_mode();
   info->SetLanguageMode(language_mode);
 
   if (!Rewriter::Rewrite(info)) return false;
   if (!Scope::Analyze(info)) return false;
+  info->ProcessFeedbackSlots();
   ASSERT(info->scope() != NULL);
   return true;
 }
 
 
 static bool GetOptimizedCodeNow(CompilationInfo* info) {
   if (!CompileOptimizedPrologue(info)) return false;
 
   Logger::TimerEventScope timer(
       info->isolate(), Logger::TimerEventScope::v8_recompile_synchronous);
@@ skipping 195 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