v8::internal::Compiler Class Reference

#include <compiler.h>

Inheritance diagram for v8::internal::Compiler:

Collaboration diagram for v8::internal::Compiler:

Public Types
enum	ConcurrencyMode { NOT_CONCURRENT , CONCURRENT }

Static Public Member Functions
static MUST_USE_RESULT MaybeHandle< Code >	GetUnoptimizedCode (Handle< JSFunction > function)
static MUST_USE_RESULT MaybeHandle< Code >	GetLazyCode (Handle< JSFunction > function)
static MUST_USE_RESULT MaybeHandle< Code >	GetUnoptimizedCode (Handle< SharedFunctionInfo > shared)
static MUST_USE_RESULT MaybeHandle< Code >	GetDebugCode (Handle< JSFunction > function)
static bool	EnsureCompiled (Handle< JSFunction > function, ClearExceptionFlag flag)
static bool	EnsureDeoptimizationSupport (CompilationInfo *info)
static void	CompileForLiveEdit (Handle< Script > script)
static MUST_USE_RESULT MaybeHandle< JSFunction >	GetFunctionFromEval (Handle< String > source, Handle< Context > context, StrictMode strict_mode, ParseRestriction restriction, int scope_position)
static Handle< SharedFunctionInfo >	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, ScriptCompiler::CompileOptions compile_options, NativesFlag is_natives_code)
static Handle< SharedFunctionInfo >	CompileStreamedScript (CompilationInfo *info, int source_length)
static Handle< SharedFunctionInfo >	BuildFunctionInfo (FunctionLiteral *node, Handle< Script > script, CompilationInfo *outer)
static MUST_USE_RESULT MaybeHandle< Code >	GetOptimizedCode (Handle< JSFunction > function, Handle< Code > current_code, ConcurrencyMode mode, BailoutId osr_ast_id=BailoutId::None())
static Handle< Code >	GetConcurrentlyOptimizedCode (OptimizedCompileJob *job)
static bool	DebuggerWantsEagerCompilation (CompilationInfo *info, bool allow_lazy_without_ctx=false)

Detailed Description

Definition at line 667 of file compiler.h.

Member Enumeration Documentation

ConcurrencyMode

enum v8::internal::Compiler::ConcurrencyMode

Enumerator
NOT_CONCURRENT
CONCURRENT

Definition at line 709 of file compiler.h.

{ NOT_CONCURRENT, CONCURRENT };

Member Function Documentation

BuildFunctionInfo()

Handle< SharedFunctionInfo > v8::internal::Compiler::BuildFunctionInfo ( FunctionLiteral *  node, Handle< Script >  script, CompilationInfo *  outer  )

static

Definition at line 1243 of file compiler.cc.

                                 {
  // 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());
  if (outer_info->will_serialize()) info.PrepareForSerializing();
 
  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);
 
 
  if (outer_info->is_toplevel() && outer_info->will_serialize()) {
    // Make sure that if the toplevel code (possibly to be serialized),
    // the inner unction must be allowed to be compiled lazily.
    DCHECK(allow_lazy);
  }
 
  // Generate code
  Handle<ScopeInfo> scope_info;
  if (FLAG_lazy && allow_lazy && !literal->is_parenthesized()) {
    Handle<Code> code = isolate->builtins()->CompileLazy();
    info.SetCode(code);
    scope_info = Handle<ScopeInfo>(ScopeInfo::Empty(isolate));
  } else if (FullCodeGenerator::MakeCode(&info)) {
    DCHECK(!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->kind(),
      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;
}

References v8::internal::Isolate::builtins(), v8::internal::CompilationInfo::code(), v8::internal::ScopeInfo::Create(), DCHECK, DebuggerWantsEagerCompilation(), v8::internal::ScopeInfo::Empty(), v8::internal::Isolate::factory(), v8::internal::CompilationInfo::feedback_vector(), v8::internal::CompilationInfo::is_toplevel(), v8::internal::CompilationInfo::isolate(), v8::internal::FullCodeGenerator::MakeCode(), v8::internal::Handle< T >::null(), v8::internal::CompilationInfo::PrepareForCompilation(), v8::internal::CompilationInfo::PrepareForSerializing(), v8::internal::RecordFunctionCompilation(), v8::internal::LiveEditFunctionTracker::RecordFunctionInfo(), v8::internal::CompilationInfo::scope(), v8::internal::CompilationInfo::SetCode(), v8::internal::SetExpectedNofPropertiesFromEstimate(), v8::internal::CompilationInfo::SetFunction(), v8::internal::SetFunctionInfo(), v8::internal::CompilationInfo::SetStrictMode(), v8::internal::CompilationInfo::will_serialize(), and v8::internal::CompilationInfo::zone().

Here is the call graph for this function:

CompileForLiveEdit()

void v8::internal::Compiler::CompileForLiveEdit ( Handle< Script >  script )

static

Definition at line 964 of file compiler.cc.

                                                       {
  // TODO(635): support extensions.
  CompilationInfoWithZone info(script);
  PostponeInterruptsScope postpone(info.isolate());
  VMState<COMPILER> state(info.isolate());
 
  info.MarkAsGlobal();
  if (!Parser::Parse(&info)) return;
 
  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());
}

References v8::internal::CompilationInfo::code(), v8::internal::CompileUnoptimizedCode(), v8::internal::ScopeInfo::Create(), v8::internal::CompilationInfo::function(), v8::internal::CompilationInfo::isolate(), v8::internal::CompilationInfo::MarkAsGlobal(), v8::internal::Parser::Parse(), v8::internal::LiveEditFunctionTracker::RecordRootFunctionInfo(), v8::internal::CompilationInfo::scope(), v8::internal::CompilationInfo::shared_info(), and v8::internal::CompilationInfo::zone().

Referenced by v8::internal::LiveEdit::GatherCompileInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileScript()

Handle< SharedFunctionInfo > v8::internal::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, ScriptCompiler::CompileOptions  compile_options, NativesFlag  is_natives_code  )

static

Definition at line 1134 of file compiler.cc.

                                                                       {
  if (compile_options == ScriptCompiler::kNoCompileOptions) {
    cached_data = NULL;
  } else if (compile_options == ScriptCompiler::kProduceParserCache ||
             compile_options == ScriptCompiler::kProduceCodeCache) {
    DCHECK(cached_data && !*cached_data);
    DCHECK(extension == NULL);
  } else {
    DCHECK(compile_options == ScriptCompiler::kConsumeParserCache ||
           compile_options == ScriptCompiler::kConsumeCodeCache);
    DCHECK(cached_data && *cached_data);
    DCHECK(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) {
    if (FLAG_serialize_toplevel &&
        compile_options == ScriptCompiler::kConsumeCodeCache &&
        !isolate->debug()->is_loaded()) {
      HistogramTimerScope timer(isolate->counters()->compile_deserialize());
      return CodeSerializer::Deserialize(isolate, *cached_data, source);
    } else {
      maybe_result = compilation_cache->LookupScript(
          source, script_name, line_offset, column_offset,
          is_shared_cross_origin, context);
    }
  }
 
  base::ElapsedTimer timer;
  if (FLAG_profile_deserialization && FLAG_serialize_toplevel &&
      compile_options == ScriptCompiler::kProduceCodeCache) {
    timer.Start();
  }
 
  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, compile_options);
    info.SetExtension(extension);
    info.SetContext(context);
    if (FLAG_serialize_toplevel &&
        compile_options == ScriptCompiler::kProduceCodeCache) {
      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 &&
          compile_options == ScriptCompiler::kProduceCodeCache) {
        HistogramTimerScope histogram_timer(
            isolate->counters()->compile_serialize());
        *cached_data = CodeSerializer::Serialize(isolate, result, source);
        if (FLAG_profile_deserialization) {
          PrintF("[Compiling and serializing %d bytes took %0.3f ms]\n",
                 (*cached_data)->length(), timer.Elapsed().InMillisecondsF());
        }
      }
    }
 
    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;
}

References v8::internal::Isolate::compilation_cache(), v8::internal::CompileToplevel(), v8::internal::Isolate::counters(), DCHECK, v8::internal::Isolate::debug(), v8::internal::CodeSerializer::Deserialize(), v8::internal::Isolate::factory(), v8::internal::Smi::FromInt(), v8::internal::Heap::global_ic_age(), v8::internal::Isolate::heap(), v8::internal::Debug::is_loaded(), v8::internal::Handle< T >::is_null(), v8::ScriptCompiler::kConsumeCodeCache, v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kNoCompileOptions, v8::ScriptCompiler::kProduceCodeCache, v8::ScriptCompiler::kProduceParserCache, v8::internal::CompilationCache::LookupScript(), v8::internal::CompilationInfo::MarkAsGlobal(), v8::internal::NATIVES_CODE, NULL, v8::internal::CompilationInfo::PrepareForSerializing(), v8::internal::PrintF(), v8::internal::CompilationCache::PutScript(), v8::internal::Isolate::ReportPendingMessages(), v8::internal::CodeSerializer::Serialize(), v8::internal::CompilationInfo::SetCachedData(), v8::internal::CompilationInfo::SetContext(), v8::internal::CompilationInfo::SetExtension(), v8::internal::CompilationInfo::SetStrictMode(), v8::internal::STRICT, and v8::internal::Script::TYPE_NATIVE.

Referenced by v8::internal::Debug::CompileDebuggerScript(), and v8::ScriptCompiler::CompileUnbound().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileStreamedScript()

Handle< SharedFunctionInfo > v8::internal::Compiler::CompileStreamedScript ( CompilationInfo *  info, int  source_length  )

static

Definition at line 1230 of file compiler.cc.

                                              {
  Isolate* isolate = info->isolate();
  isolate->counters()->total_load_size()->Increment(source_length);
  isolate->counters()->total_compile_size()->Increment(source_length);
 
  if (FLAG_use_strict) info->SetStrictMode(STRICT);
  // TODO(marja): FLAG_serialize_toplevel is not honoured and won't be; when the
  // real code caching lands, streaming needs to be adapted to use it.
  return CompileToplevel(info);
}

References v8::internal::CompileToplevel(), v8::internal::Isolate::counters(), v8::internal::CompilationInfo::isolate(), v8::internal::CompilationInfo::SetStrictMode(), and v8::internal::STRICT.

Referenced by v8::ScriptCompiler::Compile().

Here is the call graph for this function:

Here is the caller graph for this function:

DebuggerWantsEagerCompilation()

bool v8::internal::Compiler::DebuggerWantsEagerCompilation ( CompilationInfo *  info, bool  allow_lazy_without_ctx = false  )

static

Definition at line 1404 of file compiler.cc.

                                                                          {
  return LiveEditFunctionTracker::IsActive(info->isolate()) ||
         (info->isolate()->DebuggerHasBreakPoints() && !allow_lazy_without_ctx);
}

References v8::internal::Isolate::DebuggerHasBreakPoints(), v8::internal::LiveEditFunctionTracker::IsActive(), and v8::internal::CompilationInfo::isolate().

Referenced by v8::internal::BackgroundParsingTask::BackgroundParsingTask(), BuildFunctionInfo(), and v8::internal::CompileToplevel().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureCompiled()

bool v8::internal::Compiler::EnsureCompiled ( Handle< JSFunction >  function, ClearExceptionFlag  flag  )

static

Definition at line 876 of file compiler.cc.

                                                       {
  if (function->is_compiled()) return true;
  MaybeHandle<Code> maybe_code = Compiler::GetLazyCode(function);
  Handle<Code> code;
  if (!maybe_code.ToHandle(&code)) {
    if (flag == CLEAR_EXCEPTION) {
      function->GetIsolate()->clear_pending_exception();
    }
    return false;
  }
  function->ReplaceCode(*code);
  DCHECK(function->is_compiled());
  return true;
}

References v8::internal::CLEAR_EXCEPTION, DCHECK, v8::internal::flag, and GetLazyCode().

Referenced by v8::internal::Debug::EnsureDebugInfo(), v8::internal::RUNTIME_FUNCTION(), and v8::internal::Runtime_NewObjectHelper().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureDeoptimizationSupport()

bool v8::internal::Compiler::EnsureDeoptimizationSupport ( CompilationInfo *  info )

static

Definition at line 895 of file compiler.cc.

                                                                {
  if (!info->shared_info()->has_deoptimization_support()) {
    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());
    unoptimized.EnableDeoptimizationSupport();
    if (!FullCodeGenerator::MakeCode(&unoptimized)) return false;
 
    Handle<SharedFunctionInfo> shared = info->shared_info();
    shared->EnableDeoptimizationSupport(*unoptimized.code());
    shared->set_feedback_vector(*unoptimized.feedback_vector());
 
    // The scope info might not have been set if a lazily compiled
    // function is inlined before being called for the first time.
    if (shared->scope_info() == ScopeInfo::Empty(info->isolate())) {
      Handle<ScopeInfo> target_scope_info =
          ScopeInfo::Create(info->scope(), info->zone());
      shared->set_scope_info(*target_scope_info);
    }
 
    // The existing unoptimized code was replaced with the new one.
    RecordFunctionCompilation(Logger::LAZY_COMPILE_TAG, &unoptimized, shared);
  }
  return true;
}

References v8::internal::CompilationInfo::code(), v8::internal::CompilationInfo::context(), v8::internal::ScopeInfo::Create(), v8::internal::ScopeInfo::Empty(), v8::internal::CompilationInfo::EnableDeoptimizationSupport(), v8::internal::CompilationInfo::feedback_vector(), v8::internal::CompilationInfo::function(), v8::internal::CompilationInfo::isolate(), v8::internal::FullCodeGenerator::MakeCode(), v8::internal::CompilationInfo::PrepareForCompilation(), v8::internal::RecordFunctionCompilation(), v8::internal::CompilationInfo::scope(), v8::internal::CompilationInfo::SetContext(), v8::internal::CompilationInfo::SetFunction(), v8::internal::CompilationInfo::shared_info(), and v8::internal::CompilationInfo::zone().

Referenced by v8::internal::OptimizedCompileJob::CreateGraph(), v8::internal::compiler::Parse(), and v8::internal::HOptimizedGraphBuilder::TryInline().

Here is the call graph for this function:

Here is the caller graph for this function:

GetConcurrentlyOptimizedCode()

Handle< Code > v8::internal::Compiler::GetConcurrentlyOptimizedCode ( OptimizedCompileJob *  job )

static

Definition at line 1354 of file compiler.cc.

                                                                            {
  // 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);
  TimerEventScope<TimerEventRecompileSynchronous> timer(info->isolate());
 
  Handle<SharedFunctionInfo> shared = info->shared_info();
  shared->code()->set_profiler_ticks(0);
 
  // 1) Optimization on the concurrent thread 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.
  // 5) Code generation may have failed.
  if (job->last_status() == OptimizedCompileJob::SUCCEEDED) {
    if (shared->optimization_disabled()) {
      job->RetryOptimization(kOptimizationDisabled);
    } else if (info->HasAbortedDueToDependencyChange()) {
      job->RetryOptimization(kBailedOutDueToDependencyChange);
    } else if (isolate->DebuggerHasBreakPoints()) {
      job->RetryOptimization(kDebuggerHasBreakPoints);
    } else if (job->GenerateCode() == OptimizedCompileJob::SUCCEEDED) {
      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_opt) {
        PrintF("[completed optimizing ");
        info->closure()->ShortPrint();
        PrintF("]\n");
      }
      return Handle<Code>(*info->code());
    }
  }
 
  DCHECK(job->last_status() != OptimizedCompileJob::SUCCEEDED);
  if (FLAG_trace_opt) {
    PrintF("[aborted optimizing ");
    info->closure()->ShortPrint();
    PrintF(" because: %s]\n", GetBailoutReason(info->bailout_reason()));
  }
  return Handle<Code>::null();
}

References DCHECK, v8::internal::Isolate::DebuggerHasBreakPoints(), v8::internal::OptimizedCompileJob::GenerateCode(), v8::internal::SmartPointerBase< Deallocator, T >::get(), v8::internal::GetBailoutReason(), v8::internal::OptimizedCompileJob::info(), v8::internal::InsertCodeIntoOptimizedCodeMap(), v8::internal::OptimizedCompileJob::last_status(), v8::internal::Handle< T >::null(), v8::internal::PrintF(), v8::internal::RecordFunctionCompilation(), v8::internal::OptimizedCompileJob::RetryOptimization(), and v8::internal::OptimizedCompileJob::SUCCEEDED.

Referenced by v8::internal::OptimizingCompilerThread::InstallOptimizedFunctions(), and v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

GetDebugCode()

MaybeHandle< Code > v8::internal::Compiler::GetDebugCode ( Handle< JSFunction >  function )

static

Definition at line 934 of file compiler.cc.

                                                                    {
  CompilationInfoWithZone info(function);
  Isolate* isolate = info.isolate();
  VMState<COMPILER> state(isolate);
 
  info.MarkAsDebug();
 
  DCHECK(!isolate->has_pending_exception());
  Handle<Code> old_code(function->shared()->code());
  DCHECK(old_code->kind() == Code::FUNCTION);
  DCHECK(!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 {
    DCHECK_EQ(old_code->is_compiled_optimizable(),
              new_code->is_compiled_optimizable());
  }
  return maybe_new_code;
}

References v8::internal::Isolate::clear_pending_exception(), DCHECK, DCHECK_EQ, v8::internal::CompilationInfo::EnableDeoptimizationSupport(), v8::internal::GetUnoptimizedCodeCommon(), v8::internal::Isolate::has_pending_exception(), v8::internal::CompilationInfo::isolate(), v8::internal::CompilationInfo::MarkAsDebug(), v8::internal::CompilationInfo::MarkCompilingForDebugging(), and v8::internal::CompilationInfo::MarkNonOptimizable().

Referenced by v8::internal::EnsureFunctionHasDebugBreakSlots().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFunctionFromEval()

MaybeHandle< JSFunction > v8::internal::Compiler::GetFunctionFromEval ( Handle< String >  source, Handle< Context >  context, StrictMode  strict_mode, ParseRestriction  restriction, int  scope_position  )

static

Definition at line 1081 of file compiler.cc.

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

References v8::internal::Isolate::compilation_cache(), v8::internal::CompileToplevel(), v8::internal::Isolate::counters(), DCHECK, v8::internal::Isolate::factory(), v8::internal::Heap::global_ic_age(), v8::internal::Isolate::heap(), v8::internal::Handle< T >::is_null(), v8::internal::CompilationCache::LookupEval(), v8::internal::CompilationInfo::MarkAsEval(), v8::internal::CompilationInfo::MarkAsGlobal(), v8::internal::NOT_TENURED, v8::internal::CompilationCache::PutEval(), v8::internal::Debug::RecordEvalCaller(), v8::internal::CompilationInfo::SetContext(), v8::internal::CompilationInfo::SetParseRestriction(), v8::internal::CompilationInfo::SetStrictMode(), v8::internal::SLOPPY, and v8::internal::STRICT.

Referenced by v8::internal::CompileGlobalEval(), v8::internal::DebugEvaluate(), and v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

GetLazyCode()

MaybeHandle< Code > v8::internal::Compiler::GetLazyCode ( Handle< JSFunction >  function )

static

Definition at line 821 of file compiler.cc.

                                                                   {
  DCHECK(!function->GetIsolate()->has_pending_exception());
  DCHECK(!function->is_compiled());
 
  if (FLAG_turbo_asm && function->shared()->asm_function()) {
    CompilationInfoWithZone info(function);
 
    VMState<COMPILER> state(info.isolate());
    PostponeInterruptsScope postpone(info.isolate());
 
    info.SetOptimizing(BailoutId::None(),
                       Handle<Code>(function->shared()->code()));
 
    info.MarkAsContextSpecializing();
    info.MarkAsTypingEnabled();
    info.MarkAsInliningDisabled();
 
    if (GetOptimizedCodeNow(&info)) return info.code();
  }
 
  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;
}

References ASSIGN_RETURN_ON_EXCEPTION, v8::internal::CompilationInfo::code(), DCHECK, v8::internal::Isolate::DebuggerHasBreakPoints(), GetOptimizedCode(), v8::internal::GetOptimizedCodeNow(), v8::internal::GetUnoptimizedCodeCommon(), v8::internal::CompilationInfo::isolate(), v8::internal::CompilationInfo::MarkAsContextSpecializing(), v8::internal::CompilationInfo::MarkAsInliningDisabled(), v8::internal::CompilationInfo::MarkAsTypingEnabled(), v8::internal::BailoutId::None(), NOT_CONCURRENT, v8::internal::CompilationInfo::SetOptimizing(), v8::internal::CompilationInfo::shared_info(), and v8::internal::Isolate::use_crankshaft().

Referenced by EnsureCompiled(), and v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

GetOptimizedCode()

MaybeHandle< Code > v8::internal::Compiler::GetOptimizedCode ( Handle< JSFunction >  function, Handle< Code >  current_code, ConcurrencyMode  mode, BailoutId  osr_ast_id = BailoutId::None()  )

static

Definition at line 1307 of file compiler.cc.

                                                                   {
  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();
  DCHECK(AllowCompilation::IsAllowed(isolate));
  VMState<COMPILER> state(isolate);
  DCHECK(!isolate->has_pending_exception());
  PostponeInterruptsScope postpone(isolate);
 
  Handle<SharedFunctionInfo> shared = info->shared_info();
  if (shared->code()->kind() != Code::FUNCTION ||
      ScopeInfo::Empty(isolate) == shared->scope_info()) {
    // The function was never compiled. Compile it unoptimized first.
    // TODO(titzer): reuse the AST and scope info from this compile.
    CompilationInfoWithZone nested(function);
    nested.EnableDeoptimizationSupport();
    if (!GetUnoptimizedCodeCommon(&nested).ToHandle(&current_code)) {
      return MaybeHandle<Code>();
    }
    shared->ReplaceCode(*current_code);
  }
  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();
  }
 
  if (isolate->has_pending_exception()) isolate->clear_pending_exception();
  return MaybeHandle<Code>();
}

References v8::internal::Isolate::builtins(), v8::internal::Isolate::clear_pending_exception(), CONCURRENT, DCHECK, v8::internal::SmartPointerBase< Deallocator, T >::Detach(), v8::internal::ScopeInfo::Empty(), v8::internal::CompilationInfo::EnableDeoptimizationSupport(), v8::internal::SmartPointerBase< Deallocator, T >::get(), v8::internal::GetCodeFromOptimizedCodeMap(), v8::internal::GetOptimizedCodeLater(), v8::internal::GetOptimizedCodeNow(), v8::internal::GetUnoptimizedCodeCommon(), v8::internal::Isolate::has_pending_exception(), and mode().

Referenced by GetLazyCode(), and v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

GetUnoptimizedCode() [1/2]

MaybeHandle< Code > v8::internal::Compiler::GetUnoptimizedCode ( Handle< JSFunction >  function )

static

Definition at line 805 of file compiler.cc.

                                                                          {
  DCHECK(!function->GetIsolate()->has_pending_exception());
  DCHECK(!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);
  return result;
}

References ASSIGN_RETURN_ON_EXCEPTION, DCHECK, v8::internal::GetUnoptimizedCodeCommon(), and v8::internal::CompilationInfo::isolate().

Referenced by v8::internal::Debug::FindSharedFunctionInfoInScript().

Here is the call graph for this function:

Here is the caller graph for this function:

GetUnoptimizedCode() [2/2]

MaybeHandle< Code > v8::internal::Compiler::GetUnoptimizedCode ( Handle< SharedFunctionInfo >  shared )

static

Definition at line 866 of file compiler.cc.

                                       {
  DCHECK(!shared->GetIsolate()->has_pending_exception());
  DCHECK(!shared->is_compiled());
 
  CompilationInfoWithZone info(shared);
  return GetUnoptimizedCodeCommon(&info);
}

References DCHECK, and v8::internal::GetUnoptimizedCodeCommon().

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/compiler.h
• /mnt/V8SourceCode/src/compiler.cc