// 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"

#include "src/ast/scopeinfo.h"

#include "src/ast/scopes.h"

#include "src/bootstrapper.h"

#include "src/codegen.h"

#include "src/compilation-cache.h"

#include "src/compiler/pipeline.h"

#include "src/crankshaft/hydrogen.h"

#include "src/crankshaft/lithium.h"

#include "src/crankshaft/typing.h"

#include "src/debug/debug.h"

#include "src/debug/liveedit.h"

#include "src/deoptimizer.h"

#include "src/full-codegen/full-codegen.h"

#include "src/gdb-jit.h"

#include "src/interpreter/interpreter.h"

#include "src/isolate-inl.h"

#include "src/log-inl.h"

#include "src/messages.h"

#include "src/parsing/parser.h"

#include "src/parsing/rewriter.h"

#include "src/parsing/scanner-character-streams.h"

#include "src/profiler/cpu-profiler.h"

#include "src/runtime-profiler.h"

#include "src/snapshot/code-serializer.h"

#include "src/vm-state-inl.h"

namespace v8 {

namespace internal {

#define PARSE_INFO_GETTER(type, name) \

type CompilationInfo::name() const { \

CHECK(parse_info()); \

return parse_info()->name(); \

}

#define PARSE_INFO_GETTER_WITH_DEFAULT(type, name, def) \

type CompilationInfo::name() const { \

return parse_info() ? parse_info()->name() : def; \

}

PARSE_INFO_GETTER(Handle<Script>, script)

PARSE_INFO_GETTER(bool, is_eval)

PARSE_INFO_GETTER(bool, is_native)

PARSE_INFO_GETTER(bool, is_module)

PARSE_INFO_GETTER(FunctionLiteral*, literal)

PARSE_INFO_GETTER_WITH_DEFAULT(LanguageMode, language_mode, STRICT)

PARSE_INFO_GETTER_WITH_DEFAULT(Handle<JSFunction>, closure,

Handle<JSFunction>::null())

PARSE_INFO_GETTER_WITH_DEFAULT(Scope*, scope, nullptr)

PARSE_INFO_GETTER(Handle<Context>, context)

PARSE_INFO_GETTER(Handle<SharedFunctionInfo>, shared_info)

#undef PARSE_INFO_GETTER

#undef PARSE_INFO_GETTER_WITH_DEFAULT

// A wrapper around a CompilationInfo that detaches the Handles from

// the underlying DeferredHandleScope and stores them in info_ on

// destruction.

class CompilationHandleScope BASE_EMBEDDED {

public:

explicit CompilationHandleScope(CompilationInfo* info)

: deferred_(info->isolate()), info_(info) {}

~CompilationHandleScope() { info_->set_deferred_handles(deferred_.Detach()); }

private:

DeferredHandleScope deferred_;

CompilationInfo* info_;

};

// Exactly like a CompilationInfo, except being allocated via {new} and it also

// creates and enters a Zone on construction and deallocates it on destruction.

class CompilationInfoWithZone : public CompilationInfo {

public:

explicit CompilationInfoWithZone(Handle<JSFunction> function)

: CompilationInfo(new ParseInfo(&zone_, function)),

zone_(function->GetIsolate()->allocator()) {}

// Virtual destructor because a CompilationInfoWithZone has to exit the

// zone scope and get rid of dependent maps even when the destructor is

// called when cast as a CompilationInfo.

virtual ~CompilationInfoWithZone() {

DisableFutureOptimization();

dependencies()->Rollback();

delete parse_info_;

parse_info_ = nullptr;

}

private:

Zone zone_;

};

// ----------------------------------------------------------------------------

// Implementation of CompilationInfo

bool CompilationInfo::has_shared_info() const {

return parse_info_ && !parse_info_->shared_info().is_null();

}

bool CompilationInfo::has_context() const {

return parse_info_ && !parse_info_->context().is_null();

}

bool CompilationInfo::has_literal() const {

return parse_info_ && parse_info_->literal() != nullptr;

}

bool CompilationInfo::has_scope() const {

return parse_info_ && parse_info_->scope() != nullptr;

}

CompilationInfo::CompilationInfo(ParseInfo* parse_info)

: CompilationInfo(parse_info, nullptr, Code::ComputeFlags(Code::FUNCTION),

BASE, parse_info->isolate(), parse_info->zone()) {

// Compiling for the snapshot typically results in different code than

// compiling later on. This means that code recompiled with deoptimization

// support won't be "equivalent" (as defined by SharedFunctionInfo::

// EnableDeoptimizationSupport), so it will replace the old code and all

// its type feedback. To avoid this, always compile functions in the snapshot

// with deoptimization support.

if (isolate_->serializer_enabled()) EnableDeoptimizationSupport();

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()->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) {}

CompilationInfo::CompilationInfo(ParseInfo* parse_info, const char* debug_name,

Code::Flags code_flags, Mode mode,

Isolate* isolate, Zone* zone)

: parse_info_(parse_info),

isolate_(isolate),

flags_(0),

code_flags_(code_flags),

mode_(mode),

osr_ast_id_(BailoutId::None()),

zone_(zone),

deferred_handles_(nullptr),

dependencies_(isolate, zone),

bailout_reason_(kNoReason),

prologue_offset_(Code::kPrologueOffsetNotSet),

track_positions_(FLAG_hydrogen_track_positions ||

isolate->cpu_profiler()->is_profiling()),

opt_count_(has_shared_info() ? shared_info()->opt_count() : 0),

parameter_count_(0),

optimization_id_(-1),

osr_expr_stack_height_(0),

debug_name_(debug_name) {}

CompilationInfo::~CompilationInfo() {

DisableFutureOptimization();

delete deferred_handles_;

#ifdef DEBUG

// Check that no dependent maps have been added or added dependent maps have

// been rolled back or committed.

DCHECK(dependencies()->IsEmpty());

#endif // DEBUG

}

int CompilationInfo::num_parameters() const {

return has_scope() ? scope()->num_parameters() : parameter_count_;

}

int CompilationInfo::num_parameters_including_this() const {

return num_parameters() + (is_this_defined() ? 1 : 0);

}

bool CompilationInfo::is_this_defined() const { return !IsStub(); }

int CompilationInfo::num_heap_slots() const {

return has_scope() ? scope()->num_heap_slots() : 0;

}

// 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 &&

!(literal()->flags() & AstProperties::kDontSelfOptimize) &&

!literal()->dont_optimize() &&

literal()->scope()->AllowsLazyCompilation() &&

(!has_shared_info() || !shared_info()->optimization_disabled());

}

bool CompilationInfo::has_simple_parameters() {

return scope()->has_simple_parameters();

}

int CompilationInfo::TraceInlinedFunction(Handle<SharedFunctionInfo> shared,

SourcePosition position,

int parent_id) {

DCHECK(track_positions_);

int inline_id = static_cast<int>(inlined_function_infos_.size());

InlinedFunctionInfo info(parent_id, position, UnboundScript::kNoScriptId,

shared->start_position());

if (!shared->script()->IsUndefined()) {

Handle<Script> script(Script::cast(shared->script()));

info.script_id = script->id();

if (FLAG_hydrogen_track_positions && !script->source()->IsUndefined()) {

CodeTracer::Scope tracing_scope(isolate()->GetCodeTracer());

OFStream os(tracing_scope.file());

os << "--- FUNCTION SOURCE (" << shared->DebugName()->ToCString().get()

<< ") id{" << optimization_id() << "," << inline_id << "} ---\n";

{

DisallowHeapAllocation no_allocation;

int start = shared->start_position();

int len = shared->end_position() - start;

String::SubStringRange source(String::cast(script->source()), start,

len);

for (const auto& c : source) {

os << AsReversiblyEscapedUC16(c);

}

}

os << "\n--- END ---\n";

}

}

inlined_function_infos_.push_back(info);

if (FLAG_hydrogen_track_positions && inline_id != 0) {

CodeTracer::Scope tracing_scope(isolate()->GetCodeTracer());

OFStream os(tracing_scope.file());

os << "INLINE (" << shared->DebugName()->ToCString().get() << ") id{"

<< optimization_id() << "," << inline_id << "} AS " << inline_id

<< " AT " << position << std::endl;

}

return inline_id;

}

void CompilationInfo::LogDeoptCallPosition(int pc_offset, int inlining_id) {

if (!track_positions_ || IsStub()) return;

DCHECK_LT(static_cast<size_t>(inlining_id), inlined_function_infos_.size());

inlined_function_infos_.at(inlining_id).deopt_pc_offsets.push_back(pc_offset);

}

base::SmartArrayPointer<char> CompilationInfo::GetDebugName() const {

if (parse_info() && parse_info()->literal()) {

AllowHandleDereference allow_deref;

return parse_info()->literal()->debug_name()->ToCString();

}

if (parse_info() && !parse_info()->shared_info().is_null()) {

return parse_info()->shared_info()->DebugName()->ToCString();

}

const char* str = debug_name_ ? debug_name_ : "unknown";

size_t len = strlen(str) + 1;

base::SmartArrayPointer<char> name(new char[len]);

memcpy(name.get(), str, len);

return name;

}

StackFrame::Type CompilationInfo::GetOutputStackFrameType() const {

switch (output_code_kind()) {

case Code::STUB:

case Code::BYTECODE_HANDLER:

case Code::HANDLER:

case Code::BUILTIN:

return StackFrame::STUB;

case Code::WASM_FUNCTION:

return StackFrame::WASM;

case Code::JS_TO_WASM_FUNCTION:

return StackFrame::JS_TO_WASM;

case Code::WASM_TO_JS_FUNCTION:

return StackFrame::WASM_TO_JS;

default:

UNIMPLEMENTED();

return StackFrame::NONE;

}

}

bool CompilationInfo::ExpectsJSReceiverAsReceiver() {

return is_sloppy(language_mode()) && !is_native();

}

#if DEBUG

void CompilationInfo::PrintAstForTesting() {

PrintF("--- Source from AST ---\n%s\n",

PrettyPrinter(isolate()).PrintProgram(literal()));

}

#endif

// ----------------------------------------------------------------------------

// Implementation of OptimizedCompileJob

class HOptimizedGraphBuilderWithPositions: public HOptimizedGraphBuilder {

public:

explicit HOptimizedGraphBuilderWithPositions(CompilationInfo* info)

: HOptimizedGraphBuilder(info) {

}

#define DEF_VISIT(type) \

void Visit##type(type* node) override { \

SourcePosition old_position = SourcePosition::Unknown(); \

if (node->position() != RelocInfo::kNoPosition) { \

old_position = source_position(); \

SetSourcePosition(node->position()); \

} \

HOptimizedGraphBuilder::Visit##type(node); \

if (!old_position.IsUnknown()) { \

set_source_position(old_position); \

} \

}

EXPRESSION_NODE_LIST(DEF_VISIT)

#undef DEF_VISIT

#define DEF_VISIT(type) \

void Visit##type(type* node) override { \

SourcePosition old_position = SourcePosition::Unknown(); \

if (node->position() != RelocInfo::kNoPosition) { \

old_position = source_position(); \

SetSourcePosition(node->position()); \

} \

HOptimizedGraphBuilder::Visit##type(node); \

if (!old_position.IsUnknown()) { \

set_source_position(old_position); \

} \

}

STATEMENT_NODE_LIST(DEF_VISIT)

#undef DEF_VISIT

#define DEF_VISIT(type) \

void Visit##type(type* node) override { \

HOptimizedGraphBuilder::Visit##type(node); \

}

DECLARATION_NODE_LIST(DEF_VISIT)

#undef DEF_VISIT

};

OptimizedCompileJob::Status OptimizedCompileJob::CreateGraph() {

DCHECK(info()->IsOptimizing());

// Do not use Crankshaft/TurboFan if we need to be able to set break points.

if (info()->shared_info()->HasDebugInfo()) {

return AbortOptimization(kFunctionBeingDebugged);

}

// Resuming a suspended frame is not supported by Crankshaft/TurboFan.

if (info()->shared_info()->HasBuiltinFunctionId() &&

(info()->shared_info()->builtin_function_id() == kGeneratorObjectNext ||

info()->shared_info()->builtin_function_id() == kGeneratorObjectReturn ||

info()->shared_info()->builtin_function_id() == kGeneratorObjectThrow)) {

return AbortOptimization(kGeneratorResumeMethod);

}

// Limit the number of times we try to optimize functions.

const int kMaxOptCount =

FLAG_deopt_every_n_times == 0 ? FLAG_max_opt_count : 1000;

if (info()->opt_count() > kMaxOptCount) {

return AbortOptimization(kOptimizedTooManyTimes);

}

// Check the whitelist for Crankshaft.

if (!info()->shared_info()->PassesFilter(FLAG_hydrogen_filter)) {

return AbortOptimization(kHydrogenFilter);

}

// Optimization requires a version of fullcode with deoptimization support.

// Recompile the unoptimized version of the code if the current version

// doesn't have deoptimization support already.

// Otherwise, if we are gathering compilation time and space statistics

// for hydrogen, gather baseline statistics for a fullcode compilation.

bool should_recompile = !info()->shared_info()->has_deoptimization_support();

if (should_recompile || FLAG_hydrogen_stats) {

base::ElapsedTimer timer;

if (FLAG_hydrogen_stats) {

timer.Start();

}

if (!Compiler::EnsureDeoptimizationSupport(info())) {

return SetLastStatus(FAILED);

}

if (FLAG_hydrogen_stats) {

isolate()->GetHStatistics()->IncrementFullCodeGen(timer.Elapsed());

}

}

DCHECK(info()->shared_info()->has_deoptimization_support());

DCHECK(!info()->is_first_compile());

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.

bool is_unsupported_by_crankshaft_but_turbofanable =

dont_crankshaft && strcmp(FLAG_turbo_filter, "~~") == 0 &&

!optimization_disabled;

// 3. Explicitly enabled by the command-line filter.

bool passes_turbo_filter =

info()->shared_info()->PassesFilter(FLAG_turbo_filter);

// If this is OSR request, OSR must be enabled by Turbofan.

bool passes_osr_test = FLAG_turbo_osr || !info()->is_osr();

if ((is_turbofanable_asm || is_unsupported_by_crankshaft_but_turbofanable ||

passes_turbo_filter) &&

passes_osr_test) {

// Use TurboFan for the compilation.

if (FLAG_trace_opt) {

OFStream os(stdout);

os << "[compiling method " << Brief(*info()->closure())

<< " using TurboFan";

if (info()->is_osr()) os << " OSR";

os << "]" << std::endl;

}

if (info()->shared_info()->asm_function()) {

if (info()->osr_frame()) info()->MarkAsFrameSpecializing();

info()->MarkAsFunctionContextSpecializing();

} else {

if (!FLAG_always_opt) {

info()->MarkAsBailoutOnUninitialized();

}

if (FLAG_native_context_specialization) {

info()->MarkAsNativeContextSpecializing();

info()->MarkAsTypingEnabled();

}

}

if (!info()->shared_info()->asm_function() ||

FLAG_turbo_asm_deoptimization) {

info()->MarkAsDeoptimizationEnabled();

}

Timer t(this, &time_taken_to_create_graph_);

compiler::Pipeline pipeline(info());

pipeline.GenerateCode();

if (!info()->code().is_null()) {

return SetLastStatus(SUCCEEDED);

}

}

if (!isolate()->use_crankshaft() || dont_crankshaft) {

// Crankshaft is entirely disabled.

return SetLastStatus(FAILED);

}

Scope* scope = info()->scope();

if (LUnallocated::TooManyParameters(scope->num_parameters())) {

// Crankshaft would require too many Lithium operands.

return AbortOptimization(kTooManyParameters);

}

if (info()->is_osr() &&

LUnallocated::TooManyParametersOrStackSlots(scope->num_parameters(),

scope->num_stack_slots())) {

// Crankshaft would require too many Lithium operands.

return AbortOptimization(kTooManyParametersLocals);

}

if (FLAG_trace_opt) {

OFStream os(stdout);

os << "[compiling method " << Brief(*info()->closure())

<< " using Crankshaft";

if (info()->is_osr()) os << " OSR";

os << "]" << std::endl;

}

if (FLAG_trace_hydrogen) {

isolate()->GetHTracer()->TraceCompilation(info());

}

// Type-check the function.

AstTyper(info()->isolate(), info()->zone(), info()->closure(),

info()->scope(), info()->osr_ast_id(), info()->literal())

.Run();

// Optimization could have been disabled by the parser. Note that this check

// is only needed because the Hydrogen graph builder is missing some bailouts.

if (info()->shared_info()->optimization_disabled()) {

return AbortOptimization(

info()->shared_info()->disable_optimization_reason());

}

HOptimizedGraphBuilder* graph_builder =

(info()->is_tracking_positions() || FLAG_trace_ic)

? new (info()->zone()) HOptimizedGraphBuilderWithPositions(info())

: new (info()->zone()) HOptimizedGraphBuilder(info());

Timer t(this, &time_taken_to_create_graph_);

graph_ = graph_builder->CreateGraph();

if (isolate()->has_pending_exception()) {

return SetLastStatus(FAILED);

}

if (graph_ == NULL) return SetLastStatus(BAILED_OUT);

if (info()->dependencies()->HasAborted()) {

// Dependency has changed during graph creation. Let's try again later.

return RetryOptimization(kBailedOutDueToDependencyChange);

}

return SetLastStatus(SUCCEEDED);

}

OptimizedCompileJob::Status OptimizedCompileJob::OptimizeGraph() {

DisallowHeapAllocation no_allocation;

DisallowHandleAllocation no_handles;

DisallowHandleDereference no_deref;

DisallowCodeDependencyChange no_dependency_change;

DCHECK(last_status() == SUCCEEDED);

// TODO(turbofan): Currently everything is done in the first phase.

if (!info()->code().is_null()) {

return last_status();

}

Timer t(this, &time_taken_to_optimize_);

DCHECK(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) {

info_->AbortOptimization(bailout_reason);

}

return SetLastStatus(BAILED_OUT);

}

namespace {

void AddWeakObjectToCodeDependency(Isolate* isolate, Handle<HeapObject> object,

Handle<Code> code) {

Handle<WeakCell> cell = Code::WeakCellFor(code);

Heap* heap = isolate->heap();

Handle<DependentCode> dep(heap->LookupWeakObjectToCodeDependency(object));

dep = DependentCode::InsertWeakCode(dep, DependentCode::kWeakCodeGroup, cell);

heap->AddWeakObjectToCodeDependency(object, dep);

}

void RegisterWeakObjectsInOptimizedCode(Handle<Code> code) {

// TODO(turbofan): Move this to pipeline.cc once Crankshaft dies.

Isolate* const isolate = code->GetIsolate();

DCHECK(code->is_optimized_code());

std::vector<Handle<Map>> maps;

std::vector<Handle<HeapObject>> objects;

{

DisallowHeapAllocation no_gc;

int const mode_mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |

RelocInfo::ModeMask(RelocInfo::CELL);

for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {

RelocInfo::Mode mode = it.rinfo()->rmode();

if (mode == RelocInfo::CELL &&

code->IsWeakObjectInOptimizedCode(it.rinfo()->target_cell())) {

objects.push_back(handle(it.rinfo()->target_cell(), isolate));

} else if (mode == RelocInfo::EMBEDDED_OBJECT &&

code->IsWeakObjectInOptimizedCode(

it.rinfo()->target_object())) {

Handle<HeapObject> object(HeapObject::cast(it.rinfo()->target_object()),

isolate);

if (object->IsMap()) {

maps.push_back(Handle<Map>::cast(object));

} else {

objects.push_back(object);

}

}

}

}

for (Handle<Map> map : maps) {

if (map->dependent_code()->IsEmpty(DependentCode::kWeakCodeGroup)) {

isolate->heap()->AddRetainedMap(map);

}

Map::AddDependentCode(map, DependentCode::kWeakCodeGroup, code);

}

for (Handle<HeapObject> object : objects) {

AddWeakObjectToCodeDependency(isolate, object, code);

}

code->set_can_have_weak_objects(true);

}

} // namespace

OptimizedCompileJob::Status OptimizedCompileJob::GenerateCode() {

DCHECK(last_status() == SUCCEEDED);

// TODO(turbofan): Currently everything is done in the first phase.

if (!info()->code().is_null()) {

info()->dependencies()->Commit(info()->code());

if (info()->is_deoptimization_enabled()) {

info()->parse_info()->context()->native_context()->AddOptimizedCode(

*info()->code());

RegisterWeakObjectsInOptimizedCode(info()->code());

}

RecordOptimizationStats();

return last_status();

}

DCHECK(!info()->dependencies()->HasAborted());

DisallowCodeDependencyChange no_dependency_change;

DisallowJavascriptExecution no_js(isolate());

{ // Scope for timer.

Timer timer(this, &time_taken_to_codegen_);

DCHECK(chunk_ != NULL);

DCHECK(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) {

return AbortOptimization(kCodeGenerationFailed);

}

return SetLastStatus(BAILED_OUT);

}

RegisterWeakObjectsInOptimizedCode(optimized_code);

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_);

}

}

// ----------------------------------------------------------------------------

// Local helper methods that make up the compilation pipeline.

namespace {

// 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 {

// Inobject slack tracking will reclaim redundant inobject space later,

// so we can afford to adjust the estimate generously.

estimate += 8;

}

shared->set_expected_nof_properties(estimate);

}

void MaybeDisableOptimization(Handle<SharedFunctionInfo> shared_info,

BailoutReason bailout_reason) {

if (bailout_reason != kNoReason) {

shared_info->DisableOptimization(bailout_reason);

}

}

void 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->parse_info()->script();

Handle<AbstractCode> abstract_code = info->abstract_code();

if (abstract_code.is_identical_to(

info->isolate()->builtins()->CompileLazy())) {

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, *abstract_code, *shared, info, script_name,

line_num, column_num));

}

}

void EnsureFeedbackVector(CompilationInfo* info) {

if (!info->has_shared_info()) return;

// If no type feedback vector exists, we create one now. At this point the

// AstNumbering pass has already run. Note the snapshot can contain outdated

// vectors for a different configuration, hence we also recreate a new vector

// when the function is not compiled (i.e. no code was serialized).

if (info->shared_info()->feedback_vector()->is_empty() ||

!info->shared_info()->is_compiled()) {

Handle<TypeFeedbackMetadata> feedback_metadata = TypeFeedbackMetadata::New(

info->isolate(), info->literal()->feedback_vector_spec());

Handle<TypeFeedbackVector> feedback_vector =

TypeFeedbackVector::New(info->isolate(), feedback_metadata);

info->shared_info()->set_feedback_vector(*feedback_vector);

}

// It's very important that recompiles do not alter the structure of the type

// feedback vector. Verify that the structure fits the function literal.

CHECK(!info->shared_info()->feedback_vector()->metadata()->SpecDiffersFrom(

info->literal()->feedback_vector_spec()));

}

bool CompileUnoptimizedCode(CompilationInfo* info) {

DCHECK(AllowCompilation::IsAllowed(info->isolate()));

if (!Compiler::Analyze(info->parse_info()) ||

!(EnsureFeedbackVector(info), FullCodeGenerator::MakeCode(info))) {

Isolate* isolate = info->isolate();

if (!isolate->has_pending_exception()) isolate->StackOverflow();

return false;

}

return true;

}

bool UseIgnition(CompilationInfo* info) {

// TODO(4681): Generator functions are not yet supported.

if (info->shared_info()->is_generator()) {

return false;

}

// TODO(4681): Resuming a suspended frame is not supported.

if (info->shared_info()->HasBuiltinFunctionId() &&

(info->shared_info()->builtin_function_id() == kGeneratorObjectNext ||

info->shared_info()->builtin_function_id() == kGeneratorObjectReturn ||

info->shared_info()->builtin_function_id() == kGeneratorObjectThrow)) {

return false;

}

// Checks whether top level functions should be passed by the filter.

if (info->shared_info()->is_toplevel()) {

Vector<const char> filter = CStrVector(FLAG_ignition_filter);

return (filter.length() == 0) || (filter.length() == 1 && filter[0] == '*');

}

// Finally respect the filter.

return info->shared_info()->PassesFilter(FLAG_ignition_filter);

}

int CodeAndMetadataSize(CompilationInfo* info) {

int size = 0;

if (info->has_bytecode_array()) {

Handle<BytecodeArray> bytecode_array = info->bytecode_array();

size += bytecode_array->BytecodeArraySize();

size += bytecode_array->constant_pool()->Size();

size += bytecode_array->handler_table()->Size();

size += bytecode_array->source_position_table()->Size();

} else {

Handle<Code> code = info->code();

size += code->CodeSize();

size += code->relocation_info()->Size();

size += code->deoptimization_data()->Size();

size += code->handler_table()->Size();

}

return size;

}

bool GenerateBaselineCode(CompilationInfo* info) {

bool success;

EnsureFeedbackVector(info);

if (FLAG_ignition && UseIgnition(info)) {

success = interpreter::Interpreter::MakeBytecode(info);

} else {

success = FullCodeGenerator::MakeCode(info);

}

if (success) {

Isolate* isolate = info->isolate();

Counters* counters = isolate->counters();

counters->total_baseline_code_size()->Increment(CodeAndMetadataSize(info));

counters->total_baseline_compile_count()->Increment(1);

}

return success;

}

bool CompileBaselineCode(CompilationInfo* info) {

DCHECK(AllowCompilation::IsAllowed(info->isolate()));

if (!Compiler::Analyze(info->parse_info()) || !GenerateBaselineCode(info)) {

Isolate* isolate = info->isolate();

if (!isolate->has_pending_exception()) isolate->StackOverflow();

return false;

}

return true;

}

void InstallBaselineCompilationResult(CompilationInfo* info,

Handle<SharedFunctionInfo> shared,

Handle<ScopeInfo> scope_info) {

// Assert that we are not overwriting (possibly patched) debug code.

DCHECK(!shared->HasDebugCode());

DCHECK(!info->code().is_null());

shared->ReplaceCode(*info->code());

shared->set_scope_info(*scope_info);

if (info->has_bytecode_array()) {

DCHECK(!shared->HasBytecodeArray()); // Only compiled once.

shared->set_bytecode_array(*info->bytecode_array());

}

}

MUST_USE_RESULT 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());

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>();

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());

// Install compilation result on the shared function info

InstallBaselineCompilationResult(info, shared, scope_info);

return info->code();

}

MUST_USE_RESULT MaybeHandle<Code> GetCodeFromOptimizedCodeMap(

Handle<JSFunction> function, BailoutId osr_ast_id) {

Handle<SharedFunctionInfo> shared(function->shared());

DisallowHeapAllocation no_gc;

CodeAndLiterals cached = shared->SearchOptimizedCodeMap(

function->context()->native_context(), osr_ast_id);

if (cached.code != nullptr) {

// Caching of optimized code enabled and optimized code found.

if (cached.literals != nullptr) function->set_literals(cached.literals);

DCHECK(!cached.code->marked_for_deoptimization());

DCHECK(function->shared()->is_compiled());

return Handle<Code>(cached.code);

}

return MaybeHandle<Code>();

}

void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) {

Handle<Code> code = info->code();

if (code->kind() != Code::OPTIMIZED_FUNCTION) return; // Nothing to do.

// Function context specialization folds-in the function context,

// so no sharing can occur.

if (info->is_function_context_specializing()) return;

// Frame specialization implies function context specialization.

DCHECK(!info->is_frame_specializing());

// Cache optimized context-specific code.

Handle<JSFunction> function = info->closure();

Handle<SharedFunctionInfo> shared(function->shared());

Handle<LiteralsArray> literals(function->literals());

Handle<Context> native_context(function->context()->native_context());

SharedFunctionInfo::AddToOptimizedCodeMap(shared, native_context, code,

literals, info->osr_ast_id());

// Do not cache (native) context-independent code compiled for OSR.

if (code->is_turbofanned() && info->is_osr()) return;

// Cache optimized (native) context-independent code.

if (FLAG_turbo_cache_shared_code && code->is_turbofanned() &&

!info->is_native_context_specializing()) {

DCHECK(!info->is_function_context_specializing());

DCHECK(info->osr_ast_id().IsNone());

Handle<SharedFunctionInfo> shared(function->shared());

SharedFunctionInfo::AddSharedCodeToOptimizedCodeMap(shared, code);

}

}

bool Renumber(ParseInfo* parse_info) {

if (!AstNumbering::Renumber(parse_info->isolate(), parse_info->zone(),

parse_info->literal())) {

return false;

}

Handle<SharedFunctionInfo> shared_info = parse_info->shared_info();

if (!shared_info.is_null()) {

FunctionLiteral* lit = parse_info->literal();

shared_info->set_ast_node_count(lit->ast_node_count());

MaybeDisableOptimization(shared_info, lit->dont_optimize_reason());

shared_info->set_dont_crankshaft(

shared_info->dont_crankshaft() ||

(lit->flags() & AstProperties::kDontCrankshaft));

}

return true;

}

bool GetOptimizedCodeNow(CompilationInfo* info) {

Isolate* isolate = info->isolate();

CanonicalHandleScope canonical(isolate);

TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);

TRACE_EVENT0("v8", "V8.OptimizeCode");

if (!Compiler::ParseAndAnalyze(info->parse_info())) return false;

TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);

TRACE_EVENT0("v8", "V8.RecompileSynchronous");

OptimizedCompileJob job(info);

if (job.CreateGraph() != OptimizedCompileJob::SUCCEEDED ||

job.OptimizeGraph() != OptimizedCompileJob::SUCCEEDED ||

job.GenerateCode() != OptimizedCompileJob::SUCCEEDED) {

if (FLAG_trace_opt) {

PrintF("[aborted optimizing ");

info->closure()->ShortPrint();

PrintF(" because: %s]\n", GetBailoutReason(info->bailout_reason()));

}

return false;

}

// Success!

DCHECK(!isolate->has_pending_exception());

InsertCodeIntoOptimizedCodeMap(info);