// 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/v8.h" #include "src/compiler.h" #include "src/bootstrapper.h" #include "src/codegen.h" #include "src/compilation-cache.h" #include "src/cpu-profiler.h" #include "src/debug.h" #include "src/deoptimizer.h" #include "src/full-codegen.h" #include "src/gdb-jit.h" #include "src/hydrogen.h" #include "src/isolate-inl.h" #include "src/lithium.h" #include "src/liveedit.h" #include "src/parser.h" #include "src/rewriter.h" #include "src/runtime-profiler.h" #include "src/scanner-character-streams.h" #include "src/scopeinfo.h" #include "src/scopes.h" #include "src/typing.h" #include "src/vm-state-inl.h" namespace v8 { namespace internal { ScriptData::ScriptData(const byte* data, int length) : owns_data_(false), data_(data), length_(length) { if (!IsAligned(reinterpret_cast<intptr_t>(data), kPointerAlignment)) { byte* copy = NewArray<byte>(length); ASSERT(IsAligned(reinterpret_cast<intptr_t>(copy), kPointerAlignment)); CopyBytes(copy, data, length); data_ = copy; AcquireDataOwnership(); } } CompilationInfo::CompilationInfo(Handle<Script> script, Zone* zone) : flags_(StrictModeField::encode(SLOPPY)), script_(script), osr_ast_id_(BailoutId::None()), parameter_count_(0), this_has_uses_(true), optimization_id_(-1), ast_value_factory_(NULL), ast_value_factory_owned_(false) { Initialize(script->GetIsolate(), BASE, zone); } CompilationInfo::CompilationInfo(Handle<SharedFunctionInfo> shared_info, Zone* zone) : flags_(StrictModeField::encode(SLOPPY) | IsLazy::encode(true)), shared_info_(shared_info), script_(Handle<Script>(Script::cast(shared_info->script()))), osr_ast_id_(BailoutId::None()), parameter_count_(0), this_has_uses_(true), optimization_id_(-1), ast_value_factory_(NULL), ast_value_factory_owned_(false) { Initialize(script_->GetIsolate(), BASE, zone); } CompilationInfo::CompilationInfo(Handle<JSFunction> closure, Zone* zone) : flags_(StrictModeField::encode(SLOPPY) | IsLazy::encode(true)), closure_(closure), shared_info_(Handle<SharedFunctionInfo>(closure->shared())), script_(Handle<Script>(Script::cast(shared_info_->script()))), context_(closure->context()), osr_ast_id_(BailoutId::None()), parameter_count_(0), this_has_uses_(true), optimization_id_(-1), ast_value_factory_(NULL), ast_value_factory_owned_(false) { Initialize(script_->GetIsolate(), BASE, zone); } CompilationInfo::CompilationInfo(HydrogenCodeStub* stub, Isolate* isolate, Zone* zone) : flags_(StrictModeField::encode(SLOPPY) | IsLazy::encode(true)), osr_ast_id_(BailoutId::None()), parameter_count_(0), this_has_uses_(true), optimization_id_(-1), ast_value_factory_(NULL), ast_value_factory_owned_(false) { Initialize(isolate, STUB, zone); code_stub_ = stub; } void CompilationInfo::Initialize(Isolate* isolate, Mode mode, Zone* zone) { isolate_ = isolate; function_ = NULL; scope_ = NULL; global_scope_ = NULL; extension_ = NULL; cached_data_ = NULL; cached_data_mode_ = NO_CACHED_DATA; zone_ = zone; deferred_handles_ = NULL; code_stub_ = NULL; prologue_offset_ = Code::kPrologueOffsetNotSet; opt_count_ = shared_info().is_null() ? 0 : shared_info()->opt_count(); no_frame_ranges_ = isolate->cpu_profiler()->is_profiling() ? new List<OffsetRange>(2) : NULL; for (int i = 0; i < DependentCode::kGroupCount; i++) { dependencies_[i] = NULL; } if (mode == STUB) { mode_ = STUB; return; } mode_ = mode; abort_due_to_dependency_ = false; if (script_->type()->value() == Script::TYPE_NATIVE) MarkAsNative(); if (isolate_->debug()->is_active()) MarkAsDebug(); if (!shared_info_.is_null()) { ASSERT(strict_mode() == SLOPPY); SetStrictMode(shared_info_->strict_mode()); } set_bailout_reason(kUnknown); if (!shared_info().is_null() && 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<FixedArray>(shared_info()->feedback_vector(), isolate); } } CompilationInfo::~CompilationInfo() { delete deferred_handles_; delete no_frame_ranges_; if (ast_value_factory_owned_) delete ast_value_factory_; #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++) { ASSERT_EQ(NULL, dependencies_[i]); } #endif // DEBUG } void CompilationInfo::CommitDependencies(Handle<Code> code) { for (int i = 0; i < DependentCode::kGroupCount; i++) { ZoneList<Handle<HeapObject> >* group_objects = dependencies_[i]; if (group_objects == NULL) continue; ASSERT(!object_wrapper_.is_null()); for (int j = 0; j < group_objects->length(); j++) { DependentCode::DependencyGroup group = static_cast<DependentCode::DependencyGroup>(i); DependentCode* dependent_code = DependentCode::ForObject(group_objects->at(j), group); dependent_code->UpdateToFinishedCode(group, this, *code); } dependencies_[i] = NULL; // Zone-allocated, no need to delete. } } void CompilationInfo::RollbackDependencies() { // Unregister from all dependent maps if not yet committed. for (int i = 0; i < DependentCode::kGroupCount; i++) { ZoneList<Handle<HeapObject> >* group_objects = dependencies_[i]; if (group_objects == NULL) continue; for (int j = 0; j < group_objects->length(); j++) { DependentCode::DependencyGroup group = static_cast<DependentCode::DependencyGroup>(i); DependentCode* dependent_code = DependentCode::ForObject(group_objects->at(j), group); dependent_code->RemoveCompilationInfo(group, this); } dependencies_[i] = NULL; // Zone-allocated, no need to delete. } } int CompilationInfo::num_parameters() const { if (IsStub()) { ASSERT(parameter_count_ > 0); return parameter_count_; } else { return scope()->num_parameters(); } } int CompilationInfo::num_heap_slots() const { if (IsStub()) { return 0; } else { return scope()->num_heap_slots(); } } Code::Flags CompilationInfo::flags() const { if (IsStub()) { return Code::ComputeFlags(code_stub()->GetCodeKind(), code_stub()->GetICState(), code_stub()->GetExtraICState(), code_stub()->GetStubType()); } else { return Code::ComputeFlags(Code::OPTIMIZED_FUNCTION); } } // Disable optimization for the rest of the compilation pipeline. void CompilationInfo::DisableOptimization() { bool is_optimizable_closure = FLAG_optimize_closures && closure_.is_null() && !scope_->HasTrivialOuterContext() && !scope_->outer_scope_calls_sloppy_eval() && !scope_->inside_with(); SetMode(is_optimizable_closure ? BASE : NONOPT); } // Primitive functions are unlikely to be picked up by the stack-walking // profiler, so they trigger their own optimization when they're called // 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::PrepareForCompilation(Scope* scope) { ASSERT(scope_ == NULL); scope_ = scope; int length = function()->slot_count(); if (feedback_vector_.is_null()) { // Allocate the feedback vector too. feedback_vector_ = isolate()->factory()->NewTypeFeedbackVector(length); } ASSERT(feedback_vector_->length() == length); } 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()); \ } \ HOptimizedGraphBuilder::Visit##type(node); \ } EXPRESSION_NODE_LIST(DEF_VISIT) #undef DEF_VISIT #define DEF_VISIT(type) \ virtual void Visit##type(type* node) V8_OVERRIDE { \ if (node->position() != RelocInfo::kNoPosition) { \ SetSourcePosition(node->position()); \ } \ HOptimizedGraphBuilder::Visit##type(node); \ } STATEMENT_NODE_LIST(DEF_VISIT) #undef DEF_VISIT #define DEF_VISIT(type) \ virtual void Visit##type(type* node) V8_OVERRIDE { \ HOptimizedGraphBuilder::Visit##type(node); \ } MODULE_NODE_LIST(DEF_VISIT) DECLARATION_NODE_LIST(DEF_VISIT) #undef DEF_VISIT }; OptimizedCompileJob::Status OptimizedCompileJob::CreateGraph() { ASSERT(isolate()->use_crankshaft()); ASSERT(info()->IsOptimizing()); ASSERT(!info()->IsCompilingForDebugging()); // We should never arrive here if there is no code object on the // shared function object. ASSERT(info()->shared_info()->code()->kind() == Code::FUNCTION); // We should never arrive here if optimization has been disabled on the // shared function info. ASSERT(!info()->shared_info()->optimization_disabled()); // Fall back to using the full code generator if it's not possible // to use the Hydrogen-based optimizing compiler. We already have // generated code for this from the shared function object. if (FLAG_always_full_compiler) return AbortOptimization(); // Do not use crankshaft if we need to be able to set break points. if (isolate()->DebuggerHasBreakPoints()) { return AbortOptimization(kDebuggerHasBreakPoints); } // Limit the number of times we re-compile a functions with // the optimizing compiler. const int kMaxOptCount = FLAG_deopt_every_n_times == 0 ? FLAG_max_opt_count : 1000; if (info()->opt_count() > kMaxOptCount) { return AbortAndDisableOptimization(kOptimizedTooManyTimes); } // Due to an encoding limit on LUnallocated operands in the Lithium // 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::kMinFixedSlotIndex; Scope* scope = info()->scope(); if ((scope->num_parameters() + 1) > parameter_limit) { return AbortAndDisableOptimization(kTooManyParameters); } const int locals_limit = LUnallocated::kMaxFixedSlotIndex; if (info()->is_osr() && scope->num_parameters() + 1 + scope->num_stack_slots() > locals_limit) { return AbortAndDisableOptimization(kTooManyParametersLocals); } if (scope->HasIllegalRedeclaration()) { return AbortAndDisableOptimization(kFunctionWithIllegalRedeclaration); } // Take --hydrogen-filter into account. if (!info()->closure()->PassesFilter(FLAG_hydrogen_filter)) { return AbortOptimization(kHydrogenFilter); } // Recompile the unoptimized version of the code if the current version // doesn't have deoptimization support. Alternatively, we may decide to // run the full code generator to get a baseline for the compile-time // performance of the hydrogen-based compiler. bool should_recompile = !info()->shared_info()->has_deoptimization_support(); if (should_recompile || FLAG_hydrogen_stats) { base::ElapsedTimer timer; if (FLAG_hydrogen_stats) { timer.Start(); } CompilationInfoWithZone unoptimized(info()->shared_info()); // Note that we use the same AST that we will use for generating the // optimized code. unoptimized.SetFunction(info()->function()); unoptimized.PrepareForCompilation(info()->scope()); unoptimized.SetContext(info()->context()); if (should_recompile) unoptimized.EnableDeoptimizationSupport(); bool succeeded = FullCodeGenerator::MakeCode(&unoptimized); if (should_recompile) { if (!succeeded) return SetLastStatus(FAILED); Handle<SharedFunctionInfo> shared = info()->shared_info(); shared->EnableDeoptimizationSupport(*unoptimized.code()); // The existing unoptimized code was replaced with the new one. Compiler::RecordFunctionCompilation( Logger::LAZY_COMPILE_TAG, &unoptimized, shared); } if (FLAG_hydrogen_stats) { isolate()->GetHStatistics()->IncrementFullCodeGen(timer.Elapsed()); } } // Check that the unoptimized, shared code is ready for // optimizations. When using the always_opt flag we disregard the // optimizable marker in the code object and optimize anyway. This // is safe as long as the unoptimized code has deoptimization // support. ASSERT(FLAG_always_opt || info()->shared_info()->code()->optimizable()); ASSERT(info()->shared_info()->has_deoptimization_support()); if (FLAG_trace_hydrogen) { Handle<String> name = info()->function()->debug_name(); PrintF("-----------------------------------------------------------\n"); PrintF("Compiling method %s using hydrogen\n", name->ToCString().get()); isolate()->GetHTracer()->TraceCompilation(info()); } // Type-check the function. AstTyper::Run(info()); graph_builder_ = (FLAG_hydrogen_track_positions || FLAG_trace_ic) ? new(info()->zone()) HOptimizedGraphBuilderWithPositions(info()) : new(info()->zone()) HOptimizedGraphBuilder(info()); Timer t(this, &time_taken_to_create_graph_); info()->set_this_has_uses(false); graph_ = graph_builder_->CreateGraph(); if (isolate()->has_pending_exception()) { return SetLastStatus(FAILED); } // The function being compiled may have bailed out due to an inline // candidate bailing out. In such a case, we don't disable // optimization on the shared_info. ASSERT(!graph_builder_->inline_bailout() || graph_ == NULL); if (graph_ == NULL) { if (graph_builder_->inline_bailout()) { return AbortOptimization(); } else { return AbortAndDisableOptimization(); } } if (info()->HasAbortedDueToDependencyChange()) { return AbortOptimization(kBailedOutDueToDependencyChange); } return SetLastStatus(SUCCEEDED); } OptimizedCompileJob::Status OptimizedCompileJob::OptimizeGraph() { DisallowHeapAllocation no_allocation; DisallowHandleAllocation no_handles; DisallowHandleDereference no_deref; DisallowCodeDependencyChange no_dependency_change; ASSERT(last_status() == SUCCEEDED); Timer t(this, &time_taken_to_optimize_); ASSERT(graph_ != NULL); BailoutReason bailout_reason = kNoReason; if (graph_->Optimize(&bailout_reason)) { chunk_ = LChunk::NewChunk(graph_); if (chunk_ != NULL) return SetLastStatus(SUCCEEDED); } else if (bailout_reason != kNoReason) { graph_builder_->Bailout(bailout_reason); } return AbortOptimization(); } OptimizedCompileJob::Status OptimizedCompileJob::GenerateCode() { ASSERT(last_status() == SUCCEEDED); ASSERT(!info()->HasAbortedDueToDependencyChange()); DisallowCodeDependencyChange no_dependency_change; DisallowJavascriptExecution no_js(isolate()); { // Scope for timer. Timer timer(this, &time_taken_to_codegen_); ASSERT(chunk_ != NULL); ASSERT(graph_ != NULL); // Deferred handles reference objects that were accessible during // graph creation. To make sure that we don't encounter inconsistencies // between graph creation and code generation, we disallow accessing // objects through deferred handles during the latter, with exceptions. DisallowDeferredHandleDereference no_deferred_handle_deref; Handle<Code> optimized_code = chunk_->Codegen(); if (optimized_code.is_null()) { if (info()->bailout_reason() == kNoReason) { info_->set_bailout_reason(kCodeGenerationFailed); } else if (info()->bailout_reason() == kMapBecameDeprecated) { if (FLAG_trace_opt) { PrintF("[aborted optimizing "); info()->closure()->ShortPrint(); PrintF(" because a map became deprecated]\n"); } return AbortOptimization(); } else if (info()->bailout_reason() == kMapBecameUnstable) { if (FLAG_trace_opt) { PrintF("[aborted optimizing "); info()->closure()->ShortPrint(); PrintF(" because a map became unstable]\n"); } return AbortOptimization(); } return AbortAndDisableOptimization(); } info()->SetCode(optimized_code); } RecordOptimizationStats(); // Add to the weak list of optimized code objects. info()->context()->native_context()->AddOptimizedCode(*info()->code()); return SetLastStatus(SUCCEEDED); } void OptimizedCompileJob::RecordOptimizationStats() { Handle<JSFunction> function = info()->closure(); if (!function->IsOptimized()) { // Concurrent recompilation and OSR may race. Increment only once. int opt_count = function->shared()->opt_count(); function->shared()->set_opt_count(opt_count + 1); } double ms_creategraph = time_taken_to_create_graph_.InMillisecondsF(); double ms_optimize = time_taken_to_optimize_.InMillisecondsF(); double ms_codegen = time_taken_to_codegen_.InMillisecondsF(); if (FLAG_trace_opt) { PrintF("[optimizing "); function->ShortPrint(); PrintF(" - took %0.3f, %0.3f, %0.3f ms]\n", ms_creategraph, ms_optimize, ms_codegen); } if (FLAG_trace_opt_stats) { static double compilation_time = 0.0; static int compiled_functions = 0; static int code_size = 0; compilation_time += (ms_creategraph + ms_optimize + ms_codegen); compiled_functions++; code_size += function->shared()->SourceSize(); PrintF("Compiled: %d functions with %d byte source size in %fms.\n", compiled_functions, code_size, compilation_time); } if (FLAG_hydrogen_stats) { isolate()->GetHStatistics()->IncrementSubtotals(time_taken_to_create_graph_, time_taken_to_optimize_, time_taken_to_codegen_); } } // Sets the expected number of properties based on estimate from compiler. void SetExpectedNofPropertiesFromEstimate(Handle<SharedFunctionInfo> shared, int estimate) { // If no properties are added in the constructor, they are more likely // to be added later. if (estimate == 0) estimate = 2; // TODO(yangguo): check whether those heuristics are still up-to-date. // We do not shrink objects that go into a snapshot (yet), so we adjust // the estimate conservatively. if (shared->GetIsolate()->serializer_enabled()) { estimate += 2; } else if (FLAG_clever_optimizations) { // Inobject slack tracking will reclaim redundant inobject space later, // so we can afford to adjust the estimate generously. estimate += 8; } else { estimate += 3; } shared->set_expected_nof_properties(estimate); } static void UpdateSharedFunctionInfo(CompilationInfo* info) { // Update the shared function info with the compiled code and the // scope info. Please note, that the order of the shared function // info initialization is important since set_scope_info might // trigger a GC, causing the ASSERT below to be invalid if the code // was flushed. By setting the code object last we avoid this. 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()); // 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_bailout_reason(lit->dont_optimize_reason()); shared->set_ast_node_count(lit->ast_node_count()); shared->set_strict_mode(lit->strict_mode()); } // Sets the function info on a function. // The start_position points to the first '(' character after the function name // in the full script source. When counting characters in the script source the // the first character is number 0 (not 1). static void SetFunctionInfo(Handle<SharedFunctionInfo> function_info, FunctionLiteral* lit, bool is_toplevel, Handle<Script> script) { function_info->set_length(lit->parameter_count()); function_info->set_formal_parameter_count(lit->parameter_count()); function_info->set_script(*script); function_info->set_function_token_position(lit->function_token_position()); function_info->set_start_position(lit->start_position()); function_info->set_end_position(lit->end_position()); function_info->set_is_expression(lit->is_expression()); function_info->set_is_anonymous(lit->is_anonymous()); function_info->set_is_toplevel(is_toplevel); function_info->set_inferred_name(*lit->inferred_name()); function_info->set_allows_lazy_compilation(lit->AllowsLazyCompilation()); function_info->set_allows_lazy_compilation_without_context( lit->AllowsLazyCompilationWithoutContext()); function_info->set_strict_mode(lit->strict_mode()); function_info->set_uses_arguments(lit->scope()->arguments() != NULL); function_info->set_has_duplicate_parameters(lit->has_duplicate_parameters()); function_info->set_ast_node_count(lit->ast_node_count()); function_info->set_is_function(lit->is_function()); function_info->set_bailout_reason(lit->dont_optimize_reason()); 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); if (!FullCodeGenerator::MakeCode(info)) { Isolate* isolate = info->isolate(); if (!isolate->has_pending_exception()) isolate->StackOverflow(); return false; } return true; } MUST_USE_RESULT static MaybeHandle<Code> GetUnoptimizedCodeCommon( CompilationInfo* info) { VMState<COMPILER> state(info->isolate()); PostponeInterruptsScope postpone(info->isolate()); if (!Parser::Parse(info)) return MaybeHandle<Code>(); info->SetStrictMode(info->function()->strict_mode()); if (!CompileUnoptimizedCode(info)) return MaybeHandle<Code>(); Compiler::RecordFunctionCompilation( Logger::LAZY_COMPILE_TAG, info, info->shared_info()); UpdateSharedFunctionInfo(info); ASSERT_EQ(Code::FUNCTION, info->code()->kind()); return info->code(); } MaybeHandle<Code> Compiler::GetUnoptimizedCode(Handle<JSFunction> function) { ASSERT(!function->GetIsolate()->has_pending_exception()); ASSERT(!function->is_compiled()); if (function->shared()->is_compiled()) { return Handle<Code>(function->shared()->code()); } CompilationInfoWithZone info(function); Handle<Code> result; ASSIGN_RETURN_ON_EXCEPTION(info.isolate(), result, GetUnoptimizedCodeCommon(&info), Code); if (FLAG_always_opt && info.isolate()->use_crankshaft() && !info.shared_info()->optimization_disabled() && !info.isolate()->DebuggerHasBreakPoints()) { Handle<Code> opt_code; if (Compiler::GetOptimizedCode( function, result, Compiler::NOT_CONCURRENT).ToHandle(&opt_code)) { result = opt_code; } } return result; } MaybeHandle<Code> Compiler::GetUnoptimizedCode( Handle<SharedFunctionInfo> shared) { ASSERT(!shared->GetIsolate()->has_pending_exception()); ASSERT(!shared->is_compiled()); CompilationInfoWithZone info(shared); return GetUnoptimizedCodeCommon(&info); } bool Compiler::EnsureCompiled(Handle<JSFunction> function, ClearExceptionFlag flag) { if (function->is_compiled()) return true; MaybeHandle<Code> maybe_code = Compiler::GetUnoptimizedCode(function); Handle<Code> code; if (!maybe_code.ToHandle(&code)) { if (flag == CLEAR_EXCEPTION) { function->GetIsolate()->clear_pending_exception(); } return false; } function->ReplaceCode(*code); ASSERT(function->is_compiled()); return true; } // Compile full code for debugging. This code will have debug break slots // and deoptimization information. Deoptimization information is required // in case that an optimized version of this function is still activated on // the stack. It will also make sure that the full code is compiled with // the same flags as the previous version, that is flags which can change // the code generated. The current method of mapping from already compiled // full code without debug break slots to full code with debug break slots // depends on the generated code is otherwise exactly the same. // If compilation fails, just keep the existing code. MaybeHandle<Code> Compiler::GetCodeForDebugging(Handle<JSFunction> function) { CompilationInfoWithZone info(function); Isolate* isolate = info.isolate(); VMState<COMPILER> state(isolate); info.MarkAsDebug(); ASSERT(!isolate->has_pending_exception()); Handle<Code> old_code(function->shared()->code()); ASSERT(old_code->kind() == Code::FUNCTION); ASSERT(!old_code->has_debug_break_slots()); info.MarkCompilingForDebugging(); if (old_code->is_compiled_optimizable()) { info.EnableDeoptimizationSupport(); } else { info.MarkNonOptimizable(); } MaybeHandle<Code> maybe_new_code = GetUnoptimizedCodeCommon(&info); Handle<Code> new_code; if (!maybe_new_code.ToHandle(&new_code)) { isolate->clear_pending_exception(); } else { ASSERT_EQ(old_code->is_compiled_optimizable(), new_code->is_compiled_optimizable()); } return maybe_new_code; } void Compiler::CompileForLiveEdit(Handle<Script> script) { // TODO(635): support extensions. CompilationInfoWithZone info(script); PostponeInterruptsScope postpone(info.isolate()); VMState<COMPILER> state(info.isolate()); info.MarkAsGlobal(); if (!Parser::Parse(&info)) return; info.SetStrictMode(info.function()->strict_mode()); LiveEditFunctionTracker tracker(info.isolate(), info.function()); if (!CompileUnoptimizedCode(&info)) return; if (!info.shared_info().is_null()) { Handle<ScopeInfo> scope_info = ScopeInfo::Create(info.scope(), info.zone()); info.shared_info()->set_scope_info(*scope_info); } tracker.RecordRootFunctionInfo(info.code()); } static bool DebuggerWantsEagerCompilation(CompilationInfo* info, bool allow_lazy_without_ctx = false) { return LiveEditFunctionTracker::IsActive(info->isolate()) || (info->isolate()->DebuggerHasBreakPoints() && !allow_lazy_without_ctx); } static Handle<SharedFunctionInfo> CompileToplevel(CompilationInfo* info) { Isolate* isolate = info->isolate(); PostponeInterruptsScope postpone(isolate); ASSERT(!isolate->native_context().is_null()); Handle<Script> script = info->script(); // TODO(svenpanne) Obscure place for this, perhaps move to OnBeforeCompile? FixedArray* array = isolate->native_context()->embedder_data(); script->set_context_data(array->get(0)); isolate->debug()->OnBeforeCompile(script); ASSERT(info->is_eval() || info->is_global()); bool parse_allow_lazy = (info->cached_data_mode() == CONSUME_CACHED_DATA || String::cast(script->source())->length() > FLAG_min_preparse_length) && !DebuggerWantsEagerCompilation(info); if (!parse_allow_lazy && info->cached_data_mode() != NO_CACHED_DATA) { // We are going to parse eagerly, but we either 1) have cached data produced // by lazy parsing or 2) are asked to generate cached data. We cannot use // the existing data, since it won't contain all the symbols we need for // eager parsing. In addition, it doesn't make sense to produce the data // when parsing eagerly. That data would contain all symbols, but no // functions, so it cannot be used to aid lazy parsing later. info->SetCachedData(NULL, NO_CACHED_DATA); } Handle<SharedFunctionInfo> result; { VMState<COMPILER> state(info->isolate()); if (!Parser::Parse(info, parse_allow_lazy)) { return Handle<SharedFunctionInfo>::null(); } FunctionLiteral* lit = info->function(); LiveEditFunctionTracker live_edit_tracker(isolate, lit); // Measure how long it takes to do the compilation; only take the // rest of the function into account to avoid overlap with the // parsing statistics. HistogramTimer* rate = info->is_eval() ? info->isolate()->counters()->compile_eval() : info->isolate()->counters()->compile(); HistogramTimerScope timer(rate); // Compile the code. if (!CompileUnoptimizedCode(info)) { 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()), 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); PROFILE(isolate, CodeCreateEvent( log_tag, *info->code(), *result, info, *script_name)); GDBJIT(AddCode(script_name, script, info->code(), info)); // Hint to the runtime system used when allocating space for initial // property space by setting the expected number of properties for // the instances of the function. SetExpectedNofPropertiesFromEstimate(result, lit->expected_property_count()); script->set_compilation_state(Script::COMPILATION_STATE_COMPILED); live_edit_tracker.RecordFunctionInfo(result, lit, info->zone()); } isolate->debug()->OnAfterCompile(script); return result; } MaybeHandle<JSFunction> Compiler::GetFunctionFromEval( Handle<String> source, Handle<Context> context, StrictMode strict_mode, ParseRestriction restriction, int scope_position) { Isolate* isolate = source->GetIsolate(); int source_length = source->length(); isolate->counters()->total_eval_size()->Increment(source_length); isolate->counters()->total_compile_size()->Increment(source_length); CompilationCache* compilation_cache = isolate->compilation_cache(); MaybeHandle<SharedFunctionInfo> maybe_shared_info = compilation_cache->LookupEval(source, context, strict_mode, scope_position); Handle<SharedFunctionInfo> shared_info; if (!maybe_shared_info.ToHandle(&shared_info)) { Handle<Script> script = isolate->factory()->NewScript(source); CompilationInfoWithZone info(script); info.MarkAsEval(); if (context->IsNativeContext()) info.MarkAsGlobal(); info.SetStrictMode(strict_mode); info.SetParseRestriction(restriction); info.SetContext(context); Debug::RecordEvalCaller(script); shared_info = CompileToplevel(&info); if (shared_info.is_null()) { return MaybeHandle<JSFunction>(); } else { // Explicitly disable optimization for eval code. We're not yet prepared // to handle eval-code in the optimizing compiler. shared_info->DisableOptimization(kEval); // If caller is strict mode, the result must be in strict mode as well. ASSERT(strict_mode == SLOPPY || shared_info->strict_mode() == STRICT); if (!shared_info->dont_cache()) { compilation_cache->PutEval( source, context, shared_info, scope_position); } } } else if (shared_info->ic_age() != isolate->heap()->global_ic_age()) { shared_info->ResetForNewContext(isolate->heap()->global_ic_age()); } return isolate->factory()->NewFunctionFromSharedFunctionInfo( shared_info, context, NOT_TENURED); } Handle<SharedFunctionInfo> Compiler::CompileScript( Handle<String> source, Handle<Object> script_name, int line_offset, int column_offset, bool is_shared_cross_origin, Handle<Context> context, v8::Extension* extension, ScriptData** cached_data, CachedDataMode cached_data_mode, NativesFlag natives) { if (cached_data_mode == NO_CACHED_DATA) { cached_data = NULL; } else if (cached_data_mode == PRODUCE_CACHED_DATA) { ASSERT(cached_data && !*cached_data); ASSERT(extension == NULL); } else { ASSERT(cached_data_mode == CONSUME_CACHED_DATA); ASSERT(cached_data && *cached_data); ASSERT(extension == NULL); } Isolate* isolate = source->GetIsolate(); int source_length = source->length(); isolate->counters()->total_load_size()->Increment(source_length); isolate->counters()->total_compile_size()->Increment(source_length); CompilationCache* compilation_cache = isolate->compilation_cache(); // Do a lookup in the compilation cache but not for extensions. MaybeHandle<SharedFunctionInfo> maybe_result; Handle<SharedFunctionInfo> result; if (extension == NULL) { maybe_result = compilation_cache->LookupScript( source, script_name, line_offset, column_offset, is_shared_cross_origin, context); if (maybe_result.is_null() && FLAG_serialize_toplevel && cached_data_mode == CONSUME_CACHED_DATA) { Object* des = CodeSerializer::Deserialize(isolate, *cached_data); return handle(SharedFunctionInfo::cast(des), isolate); } } if (!maybe_result.ToHandle(&result)) { // No cache entry found. Compile the script. // Create a script object describing the script to be compiled. Handle<Script> script = isolate->factory()->NewScript(source); if (natives == NATIVES_CODE) { script->set_type(Smi::FromInt(Script::TYPE_NATIVE)); } if (!script_name.is_null()) { script->set_name(*script_name); script->set_line_offset(Smi::FromInt(line_offset)); script->set_column_offset(Smi::FromInt(column_offset)); } script->set_is_shared_cross_origin(is_shared_cross_origin); // Compile the function and add it to the cache. CompilationInfoWithZone info(script); info.MarkAsGlobal(); info.SetCachedData(cached_data, cached_data_mode); info.SetExtension(extension); info.SetContext(context); if (FLAG_serialize_toplevel && cached_data_mode == PRODUCE_CACHED_DATA) { info.PrepareForSerializing(); } if (FLAG_use_strict) info.SetStrictMode(STRICT); result = CompileToplevel(&info); if (extension == NULL && !result.is_null() && !result->dont_cache()) { compilation_cache->PutScript(source, context, result); if (FLAG_serialize_toplevel && cached_data_mode == PRODUCE_CACHED_DATA) { *cached_data = CodeSerializer::Serialize(result); } } if (result.is_null()) isolate->ReportPendingMessages(); } else if (result->ic_age() != isolate->heap()->global_ic_age()) { result->ResetForNewContext(isolate->heap()->global_ic_age()); } return result; } Handle<SharedFunctionInfo> Compiler::BuildFunctionInfo(FunctionLiteral* literal, Handle<Script> script) { // Precondition: code has been parsed and scopes have been analyzed. CompilationInfoWithZone info(script); info.SetFunction(literal); info.PrepareForCompilation(literal->scope()); info.SetStrictMode(literal->scope()->strict_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. // If the debugger requests compilation for break points, we cannot be // aggressive about lazy compilation, because it might trigger compilation // of functions without an outer context when setting a breakpoint through // Debug::FindSharedFunctionInfoInScript. bool allow_lazy_without_ctx = literal->AllowsLazyCompilationWithoutContext(); bool allow_lazy = literal->AllowsLazyCompilation() && !DebuggerWantsEagerCompilation(&info, allow_lazy_without_ctx); // Generate code Handle<ScopeInfo> scope_info; if (FLAG_lazy && allow_lazy && !literal->is_parenthesized()) { Handle<Code> code = isolate->builtins()->CompileUnoptimized(); info.SetCode(code); scope_info = Handle<ScopeInfo>(ScopeInfo::Empty(isolate)); } else if (FullCodeGenerator::MakeCode(&info)) { ASSERT(!info.code().is_null()); scope_info = ScopeInfo::Create(info.scope(), info.zone()); } 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, 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()); return result; } MUST_USE_RESULT static MaybeHandle<Code> GetCodeFromOptimizedCodeMap( Handle<JSFunction> function, BailoutId osr_ast_id) { if (FLAG_cache_optimized_code) { Handle<SharedFunctionInfo> shared(function->shared()); // Bound functions are not cached. if (shared->bound()) return MaybeHandle<Code>(); DisallowHeapAllocation no_gc; int index = shared->SearchOptimizedCodeMap( function->context()->native_context(), osr_ast_id); if (index > 0) { if (FLAG_trace_opt) { PrintF("[found optimized code for "); function->ShortPrint(); if (!osr_ast_id.IsNone()) { PrintF(" at OSR AST id %d", osr_ast_id.ToInt()); } PrintF("]\n"); } FixedArray* literals = shared->GetLiteralsFromOptimizedCodeMap(index); if (literals != NULL) function->set_literals(literals); return Handle<Code>(shared->GetCodeFromOptimizedCodeMap(index)); } } return MaybeHandle<Code>(); } static void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) { Handle<Code> code = info->code(); if (code->kind() != Code::OPTIMIZED_FUNCTION) return; // Nothing to do. // Cache optimized code. if (FLAG_cache_optimized_code) { Handle<JSFunction> function = info->closure(); Handle<SharedFunctionInfo> shared(function->shared()); // Do not cache bound functions. if (shared->bound()) return; Handle<FixedArray> literals(function->literals()); Handle<Context> native_context(function->context()->native_context()); SharedFunctionInfo::AddToOptimizedCodeMap( shared, native_context, code, literals, info->osr_ast_id()); } } static bool CompileOptimizedPrologue(CompilationInfo* info) { if (!Parser::Parse(info)) return false; info->SetStrictMode(info->function()->strict_mode()); if (!Rewriter::Rewrite(info)) return false; if (!Scope::Analyze(info)) return false; 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); OptimizedCompileJob job(info); if (job.CreateGraph() != OptimizedCompileJob::SUCCEEDED) return false; if (job.OptimizeGraph() != OptimizedCompileJob::SUCCEEDED) return false; if (job.GenerateCode() != OptimizedCompileJob::SUCCEEDED) return false; // Success! ASSERT(!info->isolate()->has_pending_exception()); InsertCodeIntoOptimizedCodeMap(info); Compiler::RecordFunctionCompilation( Logger::LAZY_COMPILE_TAG, info, info->shared_info()); return true; } static bool GetOptimizedCodeLater(CompilationInfo* info) { Isolate* isolate = info->isolate(); if (!isolate->optimizing_compiler_thread()->IsQueueAvailable()) { if (FLAG_trace_concurrent_recompilation) { PrintF(" ** Compilation queue full, will retry optimizing "); info->closure()->PrintName(); PrintF(" later.\n"); } return false; } CompilationHandleScope handle_scope(info); if (!CompileOptimizedPrologue(info)) return false; info->SaveHandles(); // Copy handles to the compilation handle scope. Logger::TimerEventScope timer( isolate, Logger::TimerEventScope::v8_recompile_synchronous); OptimizedCompileJob* job = new(info->zone()) OptimizedCompileJob(info); OptimizedCompileJob::Status status = job->CreateGraph(); if (status != OptimizedCompileJob::SUCCEEDED) return false; isolate->optimizing_compiler_thread()->QueueForOptimization(job); if (FLAG_trace_concurrent_recompilation) { PrintF(" ** Queued "); info->closure()->PrintName(); if (info->is_osr()) { PrintF(" for concurrent OSR at %d.\n", info->osr_ast_id().ToInt()); } else { PrintF(" for concurrent optimization.\n"); } } return true; } MaybeHandle<Code> Compiler::GetOptimizedCode(Handle<JSFunction> function, Handle<Code> current_code, ConcurrencyMode mode, BailoutId osr_ast_id) { Handle<Code> cached_code; if (GetCodeFromOptimizedCodeMap( function, osr_ast_id).ToHandle(&cached_code)) { return cached_code; } SmartPointer<CompilationInfo> info(new CompilationInfoWithZone(function)); Isolate* isolate = info->isolate(); VMState<COMPILER> state(isolate); ASSERT(!isolate->has_pending_exception()); PostponeInterruptsScope postpone(isolate); Handle<SharedFunctionInfo> shared = info->shared_info(); ASSERT_NE(ScopeInfo::Empty(isolate), shared->scope_info()); int compiled_size = shared->end_position() - shared->start_position(); isolate->counters()->total_compile_size()->Increment(compiled_size); current_code->set_profiler_ticks(0); info->SetOptimizing(osr_ast_id, current_code); if (mode == CONCURRENT) { if (GetOptimizedCodeLater(info.get())) { info.Detach(); // The background recompile job owns this now. return isolate->builtins()->InOptimizationQueue(); } } else { if (GetOptimizedCodeNow(info.get())) return info->code(); } // Failed. if (FLAG_trace_opt) { PrintF("[failed to optimize "); function->PrintName(); PrintF(": %s]\n", GetBailoutReason(info->bailout_reason())); } if (isolate->has_pending_exception()) isolate->clear_pending_exception(); return MaybeHandle<Code>(); } Handle<Code> Compiler::GetConcurrentlyOptimizedCode(OptimizedCompileJob* job) { // Take ownership of compilation info. Deleting compilation info // also tears down the zone and the recompile job. SmartPointer<CompilationInfo> info(job->info()); Isolate* isolate = info->isolate(); VMState<COMPILER> state(isolate); Logger::TimerEventScope timer( isolate, Logger::TimerEventScope::v8_recompile_synchronous); Handle<SharedFunctionInfo> shared = info->shared_info(); shared->code()->set_profiler_ticks(0); // 1) Optimization may have failed. // 2) The function may have already been optimized by OSR. Simply continue. // Except when OSR already disabled optimization for some reason. // 3) The code may have already been invalidated due to dependency change. // 4) Debugger may have been activated. if (job->last_status() != OptimizedCompileJob::SUCCEEDED || shared->optimization_disabled() || info->HasAbortedDueToDependencyChange() || isolate->DebuggerHasBreakPoints()) { return Handle<Code>::null(); } if (job->GenerateCode() != OptimizedCompileJob::SUCCEEDED) { return Handle<Code>::null(); } Compiler::RecordFunctionCompilation( Logger::LAZY_COMPILE_TAG, info.get(), shared); if (info->shared_info()->SearchOptimizedCodeMap( info->context()->native_context(), info->osr_ast_id()) == -1) { InsertCodeIntoOptimizedCodeMap(info.get()); } if (FLAG_trace_concurrent_recompilation) { PrintF(" ** Optimized code for "); info->closure()->PrintName(); PrintF(" generated.\n"); } return Handle<Code>(*info->code()); } void Compiler::RecordFunctionCompilation(Logger::LogEventsAndTags tag, CompilationInfo* info, Handle<SharedFunctionInfo> shared) { // SharedFunctionInfo is passed separately, because if CompilationInfo // was created using Script object, it will not have it. // Log the code generation. If source information is available include // script name and line number. Check explicitly whether logging is // enabled as finding the line number is not free. if (info->isolate()->logger()->is_logging_code_events() || info->isolate()->cpu_profiler()->is_profiling()) { Handle<Script> script = info->script(); Handle<Code> code = info->code(); if (code.is_identical_to( info->isolate()->builtins()->CompileUnoptimized())) { return; } int line_num = Script::GetLineNumber(script, shared->start_position()) + 1; int column_num = Script::GetColumnNumber(script, shared->start_position()) + 1; String* script_name = script->name()->IsString() ? String::cast(script->name()) : info->isolate()->heap()->empty_string(); Logger::LogEventsAndTags log_tag = Logger::ToNativeByScript(tag, *script); PROFILE(info->isolate(), CodeCreateEvent( log_tag, *code, *shared, info, script_name, line_num, column_num)); } GDBJIT(AddCode(Handle<String>(shared->DebugName()), Handle<Script>(info->script()), Handle<Code>(info->code()), info)); } CompilationPhase::CompilationPhase(const char* name, CompilationInfo* info) : name_(name), info_(info), zone_(info->isolate()) { if (FLAG_hydrogen_stats) { info_zone_start_allocation_size_ = info->zone()->allocation_size(); timer_.Start(); } } CompilationPhase::~CompilationPhase() { if (FLAG_hydrogen_stats) { unsigned size = zone()->allocation_size(); size += info_->zone()->allocation_size() - info_zone_start_allocation_size_; isolate()->GetHStatistics()->SaveTiming(name_, timer_.Elapsed(), size); } } bool CompilationPhase::ShouldProduceTraceOutput() const { // Trace if the appropriate trace flag is set and the phase name's first // character is in the FLAG_trace_phase command line parameter. 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 && base::OS::StrChr(const_cast<char*>(FLAG_trace_phase), name_[0]) != NULL); } } } // namespace v8::internal