| // Copyright 2016 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/optimized-compilation-info.h" |
| |
| #include "src/api.h" |
| #include "src/debug/debug.h" |
| #include "src/isolate.h" |
| #include "src/objects-inl.h" |
| #include "src/objects/shared-function-info.h" |
| #include "src/source-position.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| OptimizedCompilationInfo::OptimizedCompilationInfo( |
| Zone* zone, Isolate* isolate, Handle<SharedFunctionInfo> shared, |
| Handle<JSFunction> closure) |
| : OptimizedCompilationInfo({}, AbstractCode::OPTIMIZED_FUNCTION, zone) { |
| shared_info_ = shared; |
| closure_ = closure; |
| optimization_id_ = isolate->NextOptimizationId(); |
| |
| SetFlag(kCalledWithCodeStartRegister); |
| if (FLAG_function_context_specialization) MarkAsFunctionContextSpecializing(); |
| if (FLAG_turbo_splitting) MarkAsSplittingEnabled(); |
| SetFlag(kSwitchJumpTableEnabled); |
| if (FLAG_untrusted_code_mitigations) MarkAsPoisoningRegisterArguments(); |
| |
| // TODO(yangguo): Disable this in case of debugging for crbug.com/826613 |
| if (FLAG_analyze_environment_liveness) { |
| MarkAsAnalyzeEnvironmentLiveness(); |
| } |
| |
| // Collect source positions for optimized code when profiling or if debugger |
| // is active, to be able to get more precise source positions at the price of |
| // more memory consumption. |
| if (isolate->NeedsDetailedOptimizedCodeLineInfo()) { |
| MarkAsSourcePositionsEnabled(); |
| } |
| |
| SetTracingFlags(shared->PassesFilter(FLAG_trace_turbo_filter)); |
| } |
| |
| OptimizedCompilationInfo::OptimizedCompilationInfo( |
| Vector<const char> debug_name, Zone* zone, Code::Kind code_kind) |
| : OptimizedCompilationInfo( |
| debug_name, static_cast<AbstractCode::Kind>(code_kind), zone) { |
| if (code_kind == Code::BYTECODE_HANDLER) { |
| SetFlag(OptimizedCompilationInfo::kCalledWithCodeStartRegister); |
| } |
| #if ENABLE_GDB_JIT_INTERFACE |
| #if DEBUG |
| if (code_kind == Code::BUILTIN || code_kind == Code::STUB) { |
| MarkAsSourcePositionsEnabled(); |
| } |
| #endif |
| #endif |
| SetTracingFlags( |
| PassesFilter(debug_name, CStrVector(FLAG_trace_turbo_filter))); |
| // Embedded builtins don't support embedded absolute code addresses, so we |
| // cannot use jump tables. |
| if (code_kind != Code::BUILTIN) { |
| SetFlag(kSwitchJumpTableEnabled); |
| } |
| } |
| |
| OptimizedCompilationInfo::OptimizedCompilationInfo( |
| Vector<const char> debug_name, AbstractCode::Kind code_kind, Zone* zone) |
| : flags_(FLAG_untrusted_code_mitigations ? kUntrustedCodeMitigations : 0), |
| code_kind_(code_kind), |
| stub_key_(0), |
| builtin_index_(Builtins::kNoBuiltinId), |
| osr_offset_(BailoutId::None()), |
| zone_(zone), |
| deferred_handles_(nullptr), |
| bailout_reason_(BailoutReason::kNoReason), |
| optimization_id_(-1), |
| debug_name_(debug_name) {} |
| |
| OptimizedCompilationInfo::~OptimizedCompilationInfo() { |
| if (GetFlag(kDisableFutureOptimization) && has_shared_info()) { |
| shared_info()->DisableOptimization(bailout_reason()); |
| } |
| } |
| |
| void OptimizedCompilationInfo::set_deferred_handles( |
| std::shared_ptr<DeferredHandles> deferred_handles) { |
| DCHECK_NULL(deferred_handles_); |
| deferred_handles_.swap(deferred_handles); |
| } |
| |
| void OptimizedCompilationInfo::set_deferred_handles( |
| DeferredHandles* deferred_handles) { |
| DCHECK_NULL(deferred_handles_); |
| deferred_handles_.reset(deferred_handles); |
| } |
| |
| void OptimizedCompilationInfo::ReopenHandlesInNewHandleScope(Isolate* isolate) { |
| if (!shared_info_.is_null()) { |
| shared_info_ = Handle<SharedFunctionInfo>(*shared_info_, isolate); |
| } |
| if (!closure_.is_null()) { |
| closure_ = Handle<JSFunction>(*closure_, isolate); |
| } |
| } |
| |
| std::unique_ptr<char[]> OptimizedCompilationInfo::GetDebugName() const { |
| if (!shared_info().is_null()) { |
| return shared_info()->DebugName()->ToCString(); |
| } |
| Vector<const char> name_vec = debug_name_; |
| if (name_vec.is_empty()) name_vec = ArrayVector("unknown"); |
| std::unique_ptr<char[]> name(new char[name_vec.length() + 1]); |
| memcpy(name.get(), name_vec.start(), name_vec.length()); |
| name[name_vec.length()] = '\0'; |
| return name; |
| } |
| |
| StackFrame::Type OptimizedCompilationInfo::GetOutputStackFrameType() const { |
| switch (code_kind()) { |
| case Code::STUB: |
| case Code::BYTECODE_HANDLER: |
| case Code::BUILTIN: |
| return StackFrame::STUB; |
| case Code::WASM_FUNCTION: |
| return StackFrame::WASM_COMPILED; |
| case Code::JS_TO_WASM_FUNCTION: |
| return StackFrame::JS_TO_WASM; |
| case Code::WASM_TO_JS_FUNCTION: |
| return StackFrame::WASM_TO_JS; |
| case Code::WASM_INTERPRETER_ENTRY: |
| return StackFrame::WASM_INTERPRETER_ENTRY; |
| default: |
| UNIMPLEMENTED(); |
| return StackFrame::NONE; |
| } |
| } |
| |
| bool OptimizedCompilationInfo::has_context() const { |
| return !closure().is_null(); |
| } |
| |
| Context* OptimizedCompilationInfo::context() const { |
| return has_context() ? closure()->context() : nullptr; |
| } |
| |
| bool OptimizedCompilationInfo::has_native_context() const { |
| return !closure().is_null() && (closure()->native_context() != nullptr); |
| } |
| |
| Context* OptimizedCompilationInfo::native_context() const { |
| return has_native_context() ? closure()->native_context() : nullptr; |
| } |
| |
| bool OptimizedCompilationInfo::has_global_object() const { |
| return has_native_context(); |
| } |
| |
| JSGlobalObject* OptimizedCompilationInfo::global_object() const { |
| return has_global_object() ? native_context()->global_object() : nullptr; |
| } |
| |
| int OptimizedCompilationInfo::AddInlinedFunction( |
| Handle<SharedFunctionInfo> inlined_function, SourcePosition pos) { |
| int id = static_cast<int>(inlined_functions_.size()); |
| inlined_functions_.push_back(InlinedFunctionHolder(inlined_function, pos)); |
| return id; |
| } |
| |
| void OptimizedCompilationInfo::SetTracingFlags(bool passes_filter) { |
| if (!passes_filter) return; |
| if (FLAG_trace_turbo) SetFlag(kTraceTurboJson); |
| if (FLAG_trace_turbo_graph) SetFlag(kTraceTurboGraph); |
| if (FLAG_trace_turbo_scheduled) SetFlag(kTraceTurboScheduled); |
| } |
| |
| } // namespace internal |
| } // namespace v8 |