Introduced TypeFeedbackId and BailoutId types.

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 42 matching lines @@
 
 CompilationInfo::CompilationInfo(Handle<Script> script, Zone* zone)
     : isolate_(script->GetIsolate()),
       flags_(LanguageModeField::encode(CLASSIC_MODE)),
       function_(NULL),
       scope_(NULL),
       global_scope_(NULL),
       script_(script),
       extension_(NULL),
       pre_parse_data_(NULL),
-      osr_ast_id_(AstNode::kNoNumber),
+      osr_ast_id_(BailoutId::None()),
       zone_(zone),
       deferred_handles_(NULL) {
   Initialize(BASE);
 }
 
 
 CompilationInfo::CompilationInfo(Handle<SharedFunctionInfo> shared_info,
                                  Zone* zone)
     : isolate_(shared_info->GetIsolate()),
       flags_(LanguageModeField::encode(CLASSIC_MODE) |
              IsLazy::encode(true)),
       function_(NULL),
       scope_(NULL),
       global_scope_(NULL),
       shared_info_(shared_info),
       script_(Handle<Script>(Script::cast(shared_info->script()))),
       extension_(NULL),
       pre_parse_data_(NULL),
-      osr_ast_id_(AstNode::kNoNumber),
+      osr_ast_id_(BailoutId::None()),
       zone_(zone),
       deferred_handles_(NULL) {
   Initialize(BASE);
 }
 
 
 CompilationInfo::CompilationInfo(Handle<JSFunction> closure, Zone* zone)
     : isolate_(closure->GetIsolate()),
       flags_(LanguageModeField::encode(CLASSIC_MODE) |
              IsLazy::encode(true)),
       function_(NULL),
       scope_(NULL),
       global_scope_(NULL),
       closure_(closure),
       shared_info_(Handle<SharedFunctionInfo>(closure->shared())),
       script_(Handle<Script>(Script::cast(shared_info_->script()))),
       extension_(NULL),
       pre_parse_data_(NULL),
-      osr_ast_id_(AstNode::kNoNumber),
+      osr_ast_id_(BailoutId::None()),
       zone_(zone),
       deferred_handles_(NULL) {
   Initialize(BASE);
 }
 
 
 CompilationInfo::~CompilationInfo() {
   delete deferred_handles_;
 }
 
@@ skipping 137 matching lines @@
   // language, we cannot optimize functions with too many formal parameters
   // or perform on-stack replacement for function with too many
   // stack-allocated local variables.
   //
   // The encoding is as a signed value, with parameters and receiver using
   // the negative indices and locals the non-negative ones.
   const int parameter_limit = -LUnallocated::kMinFixedIndex;
   const int locals_limit = LUnallocated::kMaxFixedIndex;
   Scope* scope = info()->scope();
   if ((scope->num_parameters() + 1) > parameter_limit ||
-      (info()->osr_ast_id() != AstNode::kNoNumber &&
+      (!info()->osr_ast_id().IsNone() &&
        scope->num_parameters() + 1 + scope->num_stack_slots() > locals_limit)) {
     return AbortOptimization();
   }
 
   // Take --hydrogen-filter into account.
   Handle<String> name = info()->function()->debug_name();
   if (*FLAG_hydrogen_filter != '\0') {
     Vector<const char> filter = CStrVector(FLAG_hydrogen_filter);
     if ((filter[0] == '-'
          && name->IsEqualTo(filter.SubVector(1, filter.length())))
@@ skipping 431 matching lines @@
 
   if (V8::UseCrankshaft() &&
       !function.is_null() &&
       !shared->optimization_disabled()) {
     // If we're asked to always optimize, we compile the optimized
     // version of the function right away - unless the debugger is
     // active as it makes no sense to compile optimized code then.
     if (FLAG_always_opt &&
         !Isolate::Current()->DebuggerHasBreakPoints()) {
       CompilationInfoWithZone optimized(function);
-      optimized.SetOptimizing(AstNode::kNoNumber);
+      optimized.SetOptimizing(BailoutId::None());
       return Compiler::CompileLazy(&optimized);
     }
   }
   return true;
 }
 
 
 static void InstallCodeCommon(CompilationInfo* info) {
   Handle<SharedFunctionInfo> shared = info->shared_info();
   Handle<Code> code = info->code();
@@ skipping 108 matching lines @@
     return;
   }
 
   SmartPointer<CompilationInfo> info(new CompilationInfoWithZone(closure));
   VMState state(isolate, PARALLEL_COMPILER_PROLOGUE);
   PostponeInterruptsScope postpone(isolate);
 
   Handle<SharedFunctionInfo> shared = info->shared_info();
   int compiled_size = shared->end_position() - shared->start_position();
   isolate->counters()->total_compile_size()->Increment(compiled_size);
-  info->SetOptimizing(AstNode::kNoNumber);
+  info->SetOptimizing(BailoutId::None());
 
   {
     CompilationHandleScope handle_scope(*info);
 
     if (InstallCodeFromOptimizedCodeMap(*info)) return;
 
     if (ParserApi::Parse(*info, kNoParsingFlags)) {
       LanguageMode language_mode = info->function()->language_mode();
       info->SetLanguageMode(language_mode);
       shared->set_language_mode(language_mode);
@@ skipping 176 matching lines @@
     }
   }
 
   GDBJIT(AddCode(Handle<String>(shared->DebugName()),
                  Handle<Script>(info->script()),
                  Handle<Code>(info->code()),
                  info));
 }
 
 } }  // namespace v8::internal