runtime-compiler.cc | Explore in Territory

// Copyright 2014 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 <optional>

#include "src/asmjs/asm-js.h"
#include "src/codegen/compilation-cache.h"
#include "src/codegen/compiler.h"
#include "src/common/assert-scope.h"
#include "src/common/globals.h"
#include "src/common/message-template.h"
#include "src/deoptimizer/deoptimizer.h"
#include "src/execution/arguments-inl.h"
#include "src/execution/frames-inl.h"
#include "src/execution/isolate-inl.h"
#include "src/objects/js-array-buffer-inl.h"
#include "src/objects/objects-inl.h"
#include "src/objects/shared-function-info.h"

namespace v8::internal {

namespace {
void LogExecution(Isolate* isolate, DirectHandle<JSFunction> function) { … }
}  // namespace

RUNTIME_FUNCTION(Runtime_CompileLazy) { … }

RUNTIME_FUNCTION(Runtime_InstallBaselineCode) { … }

RUNTIME_FUNCTION(Runtime_InstallSFICode) { … }

RUNTIME_FUNCTION(Runtime_CompileOptimized) { … }

RUNTIME_FUNCTION(Runtime_FunctionLogNextExecution) { … }

RUNTIME_FUNCTION(Runtime_HealOptimizedCodeSlot) { … }

// The enum values need to match "AsmJsInstantiateResult" in
// tools/metrics/histograms/enums.xml.
enum AsmJsInstantiateResult { … };

RUNTIME_FUNCTION(Runtime_InstantiateAsmJs) { … }

namespace {

bool TryGetOptimizedOsrCode(Isolate* isolate, Tagged<FeedbackVector> vector,
                            const interpreter::BytecodeArrayIterator& it,
                            Tagged<Code>* code_out) { … }

// Deoptimize all osr'd loops which is in the same outermost loop with deopt
// exit. For example:
//  for (;;) {
//    for (;;) {
//    }  // Type a: loop start < OSR backedge < deopt exit
//    for (;;) {
//      <- Deopt
//      for (;;) {
//      }  // Type b: deopt exit < loop start < OSR backedge
//    } // Type c: loop start < deopt exit < OSR backedge
//  }  // The outermost loop
void DeoptAllOsrLoopsContainingDeoptExit(Isolate* isolate,
                                         Tagged<JSFunction> function,
                                         BytecodeOffset deopt_exit_offset) { … }

}  // namespace

RUNTIME_FUNCTION(Runtime_NotifyDeoptimized) { … }

RUNTIME_FUNCTION(Runtime_ObserveNode) { … }

RUNTIME_FUNCTION(Runtime_VerifyType) { … }

RUNTIME_FUNCTION(Runtime_CheckTurboshaftTypeOf) { … }

namespace {

void GetOsrOffsetAndFunctionForOSR(Isolate* isolate, BytecodeOffset* osr_offset,
                                   Handle<JSFunction>* function) { … }

Tagged<Object> CompileOptimizedOSR(Isolate* isolate,
                                   Handle<JSFunction> function,
                                   CodeKind min_opt_level,
                                   BytecodeOffset osr_offset) { … }

}  // namespace

RUNTIME_FUNCTION(Runtime_CompileOptimizedOSR) { … }

namespace {

Tagged<Object> CompileOptimizedOSRFromMaglev(Isolate* isolate,
                                             Handle<JSFunction> function,
                                             BytecodeOffset osr_offset) { … }

}  // namespace

RUNTIME_FUNCTION(Runtime_CompileOptimizedOSRFromMaglev) { … }

RUNTIME_FUNCTION(Runtime_CompileOptimizedOSRFromMaglevInlined) { … }

RUNTIME_FUNCTION(Runtime_LogOrTraceOptimizedOSREntry) { … }

static Tagged<Object> CompileGlobalEval(Isolate* isolate,
                                        Handle<i::Object> source_object,
                                        Handle<SharedFunctionInfo> outer_info,
                                        LanguageMode language_mode,
                                        int eval_scope_info_index,
                                        int eval_position) { … }

RUNTIME_FUNCTION(Runtime_ResolvePossiblyDirectEval) { … }

}  // namespace v8::internal
chromium/v8/src/runtime/runtime-compiler.cc
