AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[nci] Replace CompilationTarget with a new Code::Kind value

Browse Source 
With the new Turbofan variants (NCI and Turboprop), we need a way to
distinguish between them both during and after compilation. We
initially introduced CompilationTarget to track the variant during
compilation, but decided to reuse the code kind as the canonical spot to
store this information instead.

Why? Because it is an established mechanism, already available in most
of the necessary spots (inside the pipeline, on Code objects, in
profiling traces).

This CL removes CompilationTarget and adds a new
NATIVE_CONTEXT_INDEPENDENT kind, plus helper functions to determine
various things about a given code kind (e.g.: does this code kind
deopt?).

As a (very large) drive-by, refactor both Code::Kind and
AbstractCode::Kind into a new CodeKind enum class.

Bug: v8:8888
Change-Id: Ie858b9a53311b0731630be35cf5cd108dee95b39
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2336793
Commit-Queue: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Clemens Backes <clemensb@chromium.org>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Dominik Inführ <dinfuehr@chromium.org>
Reviewed-by: Georg Neis <neis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69244}
This commit is contained in:
Jakob Gruber 2020-08-05 13:48:03 +02:00 committed by Commit Bot
parent c365959fc7
commit c51041f454
105 changed files with 1166 additions and 858 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BUILD.gn
View File

@ -2768,6 +2768,8 @@ v8_source_set("v8_base_without_compiler") {
"src/objects/cell-inl.h",
"src/objects/cell.h",
"src/objects/code-inl.h",
"src/objects/code-kind.cc",
"src/objects/code-kind.h",
"src/objects/code.cc",
"src/objects/code.h",
"src/objects/compilation-cache-inl.h",

2
src/builtins/builtins.cc
View File

@ -360,7 +360,7 @@ Handle<Code> Builtins::GenerateOffHeapTrampolineFor(
? TrampolineType::kJump
: TrampolineType::kAbort);
return Factory::CodeBuilder(isolate, desc, Code::BUILTIN)
return Factory::CodeBuilder(isolate, desc, CodeKind::BUILTIN)
.set_read_only_data_container(kind_specfic_flags)
.set_self_reference(generator.CodeObject())
.set_is_executable(generate_jump_to_instruction_stream)

2
src/builtins/constants-table-builder.cc
View File

@ -118,7 +118,7 @@ void BuiltinsConstantsTableBuilder::Finalize() {
for (auto it = it_scope.begin(); it != it_scope.end(); ++it) {
uint32_t index = *it.entry();
Object value = it.key();
if (value.IsCode() && Code::cast(value).kind() == Code::BUILTIN) {
if (value.IsCode() && Code::cast(value).kind() == CodeKind::BUILTIN) {
// Replace placeholder code objects with the real builtin.
// See also: SetupIsolateDelegate::PopulateWithPlaceholders.
// TODO(jgruber): Deduplicate placeholders and their corresponding

10
src/builtins/setup-builtins-internal.cc
View File

@ -75,7 +75,7 @@ Handle<Code> BuildPlaceholder(Isolate* isolate, int32_t builtin_index) {
}
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::BUILTIN)
Handle<Code> code = Factory::CodeBuilder(isolate, desc, CodeKind::BUILTIN)
.set_self_reference(masm.CodeObject())
.set_builtin_index(builtin_index)
.Build();
@ -116,7 +116,7 @@ Code BuildWithMacroAssembler(Isolate* isolate, int32_t builtin_index,
masm.GetCode(isolate, &desc, MacroAssembler::kNoSafepointTable,
handler_table_offset);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::BUILTIN)
Handle<Code> code = Factory::CodeBuilder(isolate, desc, CodeKind::BUILTIN)
.set_self_reference(masm.CodeObject())
.set_builtin_index(builtin_index)
.Build();
@ -142,7 +142,7 @@ Code BuildAdaptor(Isolate* isolate, int32_t builtin_index,
Builtins::Generate_Adaptor(&masm, builtin_address);
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::BUILTIN)
Handle<Code> code = Factory::CodeBuilder(isolate, desc, CodeKind::BUILTIN)
.set_self_reference(masm.CodeObject())
.set_builtin_index(builtin_index)
.Build();
@ -162,7 +162,7 @@ Code BuildWithCodeStubAssemblerJS(Isolate* isolate, int32_t builtin_index,
const int argc_with_recv =
(argc == kDontAdaptArgumentsSentinel) ? 0 : argc + 1;
compiler::CodeAssemblerState state(
isolate, &zone, argc_with_recv, Code::BUILTIN, name,
isolate, &zone, argc_with_recv, CodeKind::BUILTIN, name,
PoisoningMitigationLevel::kDontPoison, builtin_index);
generator(&state);
Handle<Code> code = compiler::CodeAssembler::GenerateCode(
@ -187,7 +187,7 @@ Code BuildWithCodeStubAssemblerCS(Isolate* isolate, int32_t builtin_index,
// Ensure descriptor is already initialized.
DCHECK_LE(0, descriptor.GetRegisterParameterCount());
compiler::CodeAssemblerState state(
isolate, &zone, descriptor, Code::BUILTIN, name,
isolate, &zone, descriptor, CodeKind::BUILTIN, name,
PoisoningMitigationLevel::kDontPoison, builtin_index);
generator(&state);
Handle<Code> code = compiler::CodeAssembler::GenerateCode(

66
src/codegen/compiler.cc
View File

@ -58,32 +58,13 @@ namespace internal {
namespace {
const char* CompilationTargetName(CompilationTarget target) {
switch (target) {
case CompilationTarget::kTurbofan:
return "Turbofan";
case CompilationTarget::kNativeContextIndependent:
return "NativeContextIndependent";
}
UNREACHABLE();
}
CompilationTarget CompilationTargetOf(OptimizedCompilationInfo* info) {
return info->native_context_independent()
? CompilationTarget::kNativeContextIndependent
: CompilationTarget::kTurbofan;
}
bool IsNativeContextIndependent(CompilationTarget target) {
return target == CompilationTarget::kNativeContextIndependent;
}
bool IsForNativeContextIndependentCachingOnly(CompilationTarget target) {
return IsNativeContextIndependent(target) && !FLAG_turbo_nci_as_highest_tier;
bool IsForNativeContextIndependentCachingOnly(CodeKind kind) {
return CodeKindIsNativeContextIndependentJSFunction(kind) &&
!FLAG_turbo_nci_as_highest_tier;
}
bool IsForNativeContextIndependentCachingOnly(OptimizedCompilationInfo* info) {
return IsForNativeContextIndependentCachingOnly(CompilationTargetOf(info));
return IsForNativeContextIndependentCachingOnly(info->code_kind());
}
class CompilerTracer : public AllStatic {
@ -93,8 +74,7 @@ class CompilerTracer : public AllStatic {
OptimizedCompilationInfo* info) {
PrintF(scope.file(), "[%s ", header);
info->closure()->ShortPrint(scope.file());
PrintF(scope.file(), " (target %s)",
CompilationTargetName(CompilationTargetOf(info)));
PrintF(scope.file(), " (target %s)", CodeKindToString(info->code_kind()));
}
static void PrintTracePrefix(const CodeTracer::Scope& scope,
@ -893,8 +873,7 @@ void InsertCodeIntoOptimizedCodeCache(
// Cached NCI code currently does not use the optimization marker field.
if (IsForNativeContextIndependentCachingOnly(compilation_info)) return;
Handle<Code> code = compilation_info->code();
if (code->kind() != Code::OPTIMIZED_FUNCTION) return; // Nothing to do.
if (!CodeKindIsOptimizedJSFunction(compilation_info->code_kind())) return;
// Function context specialization folds-in the function context,
// so no sharing can occur.
@ -906,6 +885,7 @@ void InsertCodeIntoOptimizedCodeCache(
}
// Cache optimized context-specific code.
Handle<Code> code = compilation_info->code();
Handle<JSFunction> function = compilation_info->closure();
Handle<SharedFunctionInfo> shared(function->shared(), function->GetIsolate());
Handle<NativeContext> native_context(function->context().native_context(),
@ -922,7 +902,7 @@ void InsertCodeIntoOptimizedCodeCache(
void InsertCodeIntoCompilationCache(Isolate* isolate,
OptimizedCompilationInfo* info) {
if (!info->native_context_independent()) return;
if (!CodeKindIsNativeContextIndependentJSFunction(info->code_kind())) return;
// TODO(jgruber,v8:8888): This should turn into a DCHECK once we
// spawn dedicated NCI compile tasks.
@ -930,7 +910,6 @@ void InsertCodeIntoCompilationCache(Isolate* isolate,
Handle<Code> code = info->code();
DCHECK(!info->function_context_specializing());
DCHECK_EQ(code->kind(), Code::OPTIMIZED_FUNCTION);
Handle<SharedFunctionInfo> sfi = info->shared_info();
CompilationCache* cache = isolate->compilation_cache();
@ -1004,10 +983,11 @@ bool GetOptimizedCodeLater(OptimizedCompilationJob* job, Isolate* isolate) {
}
MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
ConcurrencyMode mode,
CompilationTarget compilation_target,
ConcurrencyMode mode, CodeKind code_kind,
BailoutId osr_offset = BailoutId::None(),
JavaScriptFrame* osr_frame = nullptr) {
DCHECK(CodeKindIsOptimizedJSFunction(code_kind));
Isolate* isolate = function->GetIsolate();
Handle<SharedFunctionInfo> shared(function->shared(), isolate);
@ -1038,7 +1018,7 @@ MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
PendingOptimizationTable::FunctionWasOptimized(isolate, function);
}
if (!IsForNativeContextIndependentCachingOnly(compilation_target)) {
if (!IsForNativeContextIndependentCachingOnly(code_kind)) {
Handle<Code> cached_code;
if (GetCodeFromOptimizedCodeCache(function, osr_offset)
.ToHandle(&cached_code)) {
@ -1051,7 +1031,7 @@ MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
DCHECK(shared->is_compiled());
function->feedback_vector().set_profiler_ticks(0);
if (IsNativeContextIndependent(compilation_target)) {
if (CodeKindIsNativeContextIndependentJSFunction(code_kind)) {
// We don't generate NCI code for OSR.
DCHECK_EQ(osr_offset, BailoutId::None());
// Don't generate NCI code when we've already done so in the past.
@ -1074,9 +1054,8 @@ MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
// tolerate the lack of a script without bytecode.
DCHECK_IMPLIES(!has_script, shared->HasBytecodeArray());
std::unique_ptr<OptimizedCompilationJob> job(
compiler::Pipeline::NewCompilationJob(
isolate, function, has_script, osr_offset, osr_frame,
IsNativeContextIndependent(compilation_target)));
compiler::Pipeline::NewCompilationJob(isolate, function, code_kind,
has_script, osr_offset, osr_frame));
OptimizedCompilationInfo* compilation_info = job->compilation_info();
// In case of concurrent recompilation, all handles below this point will be
@ -1098,7 +1077,7 @@ MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
job.release(); // The background recompile job owns this now.
// Set the optimization marker and return a code object which checks it.
if (!IsForNativeContextIndependentCachingOnly(compilation_target)) {
if (!IsForNativeContextIndependentCachingOnly(code_kind)) {
// Cached NCI code currently does not use the optimization marker field.
function->SetOptimizationMarker(
OptimizationMarker::kInOptimizationQueue);
@ -1778,7 +1757,7 @@ bool Compiler::Compile(Handle<JSFunction> function, ClearExceptionFlag flag,
Handle<Code> maybe_code;
if (GetOptimizedCode(function, ConcurrencyMode::kNotConcurrent,
DefaultCompilationTarget())
CodeKindForTopTier())
.ToHandle(&maybe_code)) {
code = maybe_code;
}
@ -1839,15 +1818,16 @@ bool Compiler::FinalizeBackgroundCompileTask(
// static
bool Compiler::CompileOptimized(Handle<JSFunction> function,
ConcurrencyMode mode,
CompilationTarget target) {
ConcurrencyMode mode, CodeKind code_kind) {
DCHECK(CodeKindIsOptimizedJSFunction(code_kind));
if (function->IsOptimized()) return true;
Isolate* isolate = function->GetIsolate();
DCHECK(AllowCompilation::IsAllowed(isolate));
Handle<Code> code;
if (!GetOptimizedCode(function, mode, target).ToHandle(&code)) {
if (!GetOptimizedCode(function, mode, code_kind).ToHandle(&code)) {
// Optimization failed, get unoptimized code. Unoptimized code must exist
// already if we are optimizing.
DCHECK(!isolate->has_pending_exception());
@ -1856,7 +1836,7 @@ bool Compiler::CompileOptimized(Handle<JSFunction> function,
code = BUILTIN_CODE(isolate, InterpreterEntryTrampoline);
}
if (!IsForNativeContextIndependentCachingOnly(target)) {
if (!IsForNativeContextIndependentCachingOnly(code_kind)) {
function->set_code(*code);
}
@ -2913,7 +2893,7 @@ MaybeHandle<Code> Compiler::GetOptimizedCodeForOSR(Handle<JSFunction> function,
DCHECK(!osr_offset.IsNone());
DCHECK_NOT_NULL(osr_frame);
return GetOptimizedCode(function, ConcurrencyMode::kNotConcurrent,
CompilationTarget::kTurbofan, osr_offset, osr_frame);
CodeKindForOSR(), osr_offset, osr_frame);
}
// static

13
src/codegen/compiler.h
View File

@ -43,17 +43,6 @@ class WorkerThreadRuntimeCallStats;
using UnoptimizedCompilationJobList =
std::forward_list<std::unique_ptr<UnoptimizedCompilationJob>>;
enum class CompilationTarget : uint8_t {
kTurbofan,
kNativeContextIndependent,
};
inline CompilationTarget DefaultCompilationTarget() {
return FLAG_turbo_nci_as_highest_tier
? CompilationTarget::kNativeContextIndependent
: CompilationTarget::kTurbofan;
}
inline bool ShouldSpawnExtraNativeContextIndependentCompilationJob() {
return FLAG_turbo_nci && !FLAG_turbo_nci_as_highest_tier;
}
@ -84,7 +73,7 @@ class V8_EXPORT_PRIVATE Compiler : public AllStatic {
static bool Compile(Handle<JSFunction> function, ClearExceptionFlag flag,
IsCompiledScope* is_compiled_scope);
static bool CompileOptimized(Handle<JSFunction> function,
ConcurrencyMode mode, CompilationTarget target);
ConcurrencyMode mode, CodeKind code_kind);
// Collect source positions for a function that has already been compiled to
// bytecode, but for which source positions were not collected (e.g. because

75
src/codegen/optimized-compilation-info.cc
View File

@ -19,8 +19,8 @@ namespace internal {
OptimizedCompilationInfo::OptimizedCompilationInfo(
Zone* zone, Isolate* isolate, Handle<SharedFunctionInfo> shared,
Handle<JSFunction> closure, bool native_context_independent)
: code_kind_(Code::OPTIMIZED_FUNCTION),
Handle<JSFunction> closure, CodeKind code_kind)
: code_kind_(code_kind),
zone_(zone),
optimization_id_(isolate->NextOptimizationId()) {
DCHECK_EQ(*shared, closure->shared());
@ -37,13 +37,12 @@ OptimizedCompilationInfo::OptimizedCompilationInfo(
set_source_positions();
}
if (native_context_independent) set_native_context_independent();
SetTracingFlags(shared->PassesFilter(FLAG_trace_turbo_filter));
ConfigureFlags();
}
OptimizedCompilationInfo::OptimizedCompilationInfo(
Vector<const char> debug_name, Zone* zone, Code::Kind code_kind)
Vector<const char> debug_name, Zone* zone, CodeKind code_kind)
: code_kind_(code_kind),
zone_(zone),
optimization_id_(kNoOptimizationId),
@ -59,7 +58,7 @@ bool OptimizedCompilationInfo::FlagSetIsValid(Flag flag) const {
case kPoisonRegisterArguments:
return untrusted_code_mitigations();
case kFunctionContextSpecializing:
return !native_context_independent();
return !IsNativeContextIndependent();
default:
return true;
}
@ -82,41 +81,32 @@ void OptimizedCompilationInfo::ConfigureFlags() {
if (FLAG_untrusted_code_mitigations) set_untrusted_code_mitigations();
switch (code_kind_) {
case Code::OPTIMIZED_FUNCTION:
set_called_with_code_start_register();
set_switch_jump_table();
if (FLAG_function_context_specialization &&
!native_context_independent()) {
case CodeKind::OPTIMIZED_FUNCTION:
if (FLAG_function_context_specialization) {
set_function_context_specializing();
}
if (FLAG_turbo_splitting) {
set_splitting();
}
if (FLAG_untrusted_code_mitigations) {
set_poison_register_arguments();
}
if (FLAG_analyze_environment_liveness) {
// TODO(yangguo): Disable this in case of debugging for crbug.com/826613
set_analyze_environment_liveness();
}
break;
case Code::BYTECODE_HANDLER:
V8_FALLTHROUGH;
case CodeKind::NATIVE_CONTEXT_INDEPENDENT:
set_called_with_code_start_register();
if (FLAG_turbo_splitting) {
set_splitting();
}
set_switch_jump_table();
if (FLAG_turbo_splitting) set_splitting();
if (FLAG_untrusted_code_mitigations) set_poison_register_arguments();
// TODO(yangguo): Disable this in case of debugging for crbug.com/826613
if (FLAG_analyze_environment_liveness) set_analyze_environment_liveness();
break;
case Code::BUILTIN:
case Code::STUB:
if (FLAG_turbo_splitting) {
set_splitting();
}
case CodeKind::BYTECODE_HANDLER:
set_called_with_code_start_register();
if (FLAG_turbo_splitting) set_splitting();
break;
case CodeKind::BUILTIN:
case CodeKind::STUB:
if (FLAG_turbo_splitting) set_splitting();
#if ENABLE_GDB_JIT_INTERFACE && DEBUG
set_source_positions();
#endif // ENABLE_GDB_JIT_INTERFACE && DEBUG
break;
case Code::WASM_FUNCTION:
case Code::WASM_TO_CAPI_FUNCTION:
case CodeKind::WASM_FUNCTION:
case CodeKind::WASM_TO_CAPI_FUNCTION:
set_switch_jump_table();
break;
default:
@ -183,19 +173,19 @@ std::unique_ptr<char[]> OptimizedCompilationInfo::GetDebugName() const {
StackFrame::Type OptimizedCompilationInfo::GetOutputStackFrameType() const {
switch (code_kind()) {
case Code::STUB:
case Code::BYTECODE_HANDLER:
case Code::BUILTIN:
case CodeKind::STUB:
case CodeKind::BYTECODE_HANDLER:
case CodeKind::BUILTIN:
return StackFrame::STUB;
case Code::WASM_FUNCTION:
case CodeKind::WASM_FUNCTION:
return StackFrame::WASM;
case Code::WASM_TO_CAPI_FUNCTION:
case CodeKind::WASM_TO_CAPI_FUNCTION:
return StackFrame::WASM_EXIT;
case Code::JS_TO_WASM_FUNCTION:
case CodeKind::JS_TO_WASM_FUNCTION:
return StackFrame::JS_TO_WASM;
case Code::WASM_TO_JS_FUNCTION:
case CodeKind::WASM_TO_JS_FUNCTION:
return StackFrame::WASM_TO_JS;
case Code::C_WASM_ENTRY:
case CodeKind::C_WASM_ENTRY:
return StackFrame::C_WASM_ENTRY;
default:
UNIMPLEMENTED();
@ -203,6 +193,11 @@ StackFrame::Type OptimizedCompilationInfo::GetOutputStackFrameType() const {
}
}
void OptimizedCompilationInfo::SetCode(Handle<Code> code) {
DCHECK_EQ(code->kind(), code_kind());
code_ = code;
}
void OptimizedCompilationInfo::SetWasmCompilationResult(
std::unique_ptr<wasm::WasmCompilationResult> wasm_compilation_result) {
wasm_compilation_result_ = std::move(wasm_compilation_result);

27
src/codegen/optimized-compilation-info.h
View File

@ -68,8 +68,7 @@ class V8_EXPORT_PRIVATE OptimizedCompilationInfo final {
V(WasmRuntimeExceptionSupport, wasm_runtime_exception_support, 18) \
V(TurboControlFlowAwareAllocation, turbo_control_flow_aware_allocation, 19) \
V(TurboPreprocessRanges, turbo_preprocess_ranges, 20) \
V(ConcurrentInlining, concurrent_inlining, 21) \
V(NativeContextIndependent, native_context_independent, 22)
V(ConcurrentInlining, concurrent_inlining, 21)
enum Flag {
#define DEF_ENUM(Camel, Lower, Bit) k##Camel = 1 << Bit,
@ -101,11 +100,10 @@ class V8_EXPORT_PRIVATE OptimizedCompilationInfo final {
// Construct a compilation info for optimized compilation.
OptimizedCompilationInfo(Zone* zone, Isolate* isolate,
Handle<SharedFunctionInfo> shared,
Handle<JSFunction> closure,
bool native_context_independent);
Handle<JSFunction> closure, CodeKind code_kind);
// Construct a compilation info for stub compilation, Wasm, and testing.
OptimizedCompilationInfo(Vector<const char> debug_name, Zone* zone,
Code::Kind code_kind);
CodeKind code_kind);
~OptimizedCompilationInfo();
@ -117,7 +115,7 @@ class V8_EXPORT_PRIVATE OptimizedCompilationInfo final {
bool has_bytecode_array() const { return !bytecode_array_.is_null(); }
Handle<JSFunction> closure() const { return closure_; }
Handle<Code> code() const { return code_; }
Code::Kind code_kind() const { return code_kind_; }
CodeKind code_kind() const { return code_kind_; }
int32_t builtin_index() const { return builtin_index_; }
void set_builtin_index(int32_t index) { builtin_index_ = index; }
BailoutId osr_offset() const { return osr_offset_; }
@ -132,7 +130,7 @@ class V8_EXPORT_PRIVATE OptimizedCompilationInfo final {
// Code getters and setters.
void SetCode(Handle<Code> code) { code_ = code; }
void SetCode(Handle<Code> code);
void SetWasmCompilationResult(std::unique_ptr<wasm::WasmCompilationResult>);
std::unique_ptr<wasm::WasmCompilationResult> ReleaseWasmCompilationResult();
@ -147,12 +145,15 @@ class V8_EXPORT_PRIVATE OptimizedCompilationInfo final {
JSGlobalObject global_object() const;
// Accessors for the different compilation modes.
bool IsOptimizing() const { return code_kind() == Code::OPTIMIZED_FUNCTION; }
bool IsWasm() const { return code_kind() == Code::WASM_FUNCTION; }
bool IsNotOptimizedFunctionOrWasmFunction() const {
return code_kind() != Code::OPTIMIZED_FUNCTION &&
code_kind() != Code::WASM_FUNCTION;
bool IsOptimizing() const {
return CodeKindIsOptimizedJSFunction(code_kind());
}
bool IsNativeContextIndependent() const {
return code_kind() == CodeKind::NATIVE_CONTEXT_INDEPENDENT;
}
bool IsStub() const { return code_kind() == CodeKind::STUB; }
bool IsWasm() const { return code_kind() == CodeKind::WASM_FUNCTION; }
void SetOptimizingForOsr(BailoutId osr_offset, JavaScriptFrame* osr_frame) {
DCHECK(IsOptimizing());
osr_offset_ = osr_offset;
@ -239,7 +240,7 @@ class V8_EXPORT_PRIVATE OptimizedCompilationInfo final {
PoisoningMitigationLevel poisoning_level_ =
PoisoningMitigationLevel::kDontPoison;
const Code::Kind code_kind_;
const CodeKind code_kind_;
int32_t builtin_index_ = -1;
// We retain a reference the bytecode array specifically to ensure it doesn't

2
src/codegen/reloc-info.cc
View File

@ -471,7 +471,7 @@ void RelocInfo::Print(Isolate* isolate, std::ostream& os) { // NOLINT
const Address code_target = target_address();
Code code = Code::GetCodeFromTargetAddress(code_target);
DCHECK(code.IsCode());
os << " (" << Code::Kind2String(code.kind());
os << " (" << CodeKindToString(code.kind());
if (Builtins::IsBuiltin(code)) {
os << " " << Builtins::name(code.builtin_index());
}

25
src/compiler/backend/code-generator.cc
View File

@ -92,11 +92,11 @@ CodeGenerator::CodeGenerator(
CreateFrameAccessState(frame);
CHECK_EQ(info->is_osr(), osr_helper_.has_value());
tasm_.set_jump_optimization_info(jump_opt);
Code::Kind code_kind = info->code_kind();
if (code_kind == Code::WASM_FUNCTION ||
code_kind == Code::WASM_TO_CAPI_FUNCTION ||
code_kind == Code::WASM_TO_JS_FUNCTION ||
code_kind == Code::JS_TO_WASM_FUNCTION) {
CodeKind code_kind = info->code_kind();
if (code_kind == CodeKind::WASM_FUNCTION ||
code_kind == CodeKind::WASM_TO_CAPI_FUNCTION ||
code_kind == CodeKind::WASM_TO_JS_FUNCTION ||
code_kind == CodeKind::JS_TO_WASM_FUNCTION) {
tasm_.set_abort_hard(true);
}
tasm_.set_builtin_index(builtin_index);
@ -202,8 +202,7 @@ void CodeGenerator::AssembleCode() {
tasm()->CodeEntry();
// Check that {kJavaScriptCallCodeStartRegister} has been set correctly.
if (FLAG_debug_code && (info->code_kind() == Code::OPTIMIZED_FUNCTION ||
info->code_kind() == Code::BYTECODE_HANDLER)) {
if (FLAG_debug_code && info->called_with_code_start_register()) {
tasm()->RecordComment("-- Prologue: check code start register --");
AssembleCodeStartRegisterCheck();
}
@ -515,7 +514,7 @@ MaybeHandle<Code> CodeGenerator::FinalizeCode() {
// TODO(jgruber,v8:8888): Turn this into a DCHECK once confidence is
// high that the implementation is complete.
CHECK_IMPLIES(info()->native_context_independent(),
CHECK_IMPLIES(info()->IsNativeContextIndependent(),
code->IsNativeContextIndependent(isolate()));
isolate()->counters()->total_compiled_code_size()->Increment(
@ -834,7 +833,7 @@ void CodeGenerator::AssembleSourcePosition(SourcePosition source_position) {
source_position, false);
if (FLAG_code_comments) {
OptimizedCompilationInfo* info = this->info();
if (info->IsNotOptimizedFunctionOrWasmFunction()) return;
if (!info->IsOptimizing() && !info->IsWasm()) return;
std::ostringstream buffer;
buffer << "-- ";
// Turbolizer only needs the source position, as it can reconstruct
@ -865,10 +864,10 @@ bool CodeGenerator::GetSlotAboveSPBeforeTailCall(Instruction* instr,
}
StubCallMode CodeGenerator::DetermineStubCallMode() const {
Code::Kind code_kind = info()->code_kind();
return (code_kind == Code::WASM_FUNCTION ||
code_kind == Code::WASM_TO_CAPI_FUNCTION ||
code_kind == Code::WASM_TO_JS_FUNCTION)
CodeKind code_kind = info()->code_kind();
return (code_kind == CodeKind::WASM_FUNCTION ||
code_kind == CodeKind::WASM_TO_CAPI_FUNCTION ||
code_kind == CodeKind::WASM_TO_JS_FUNCTION)
? StubCallMode::kCallWasmRuntimeStub
: StubCallMode::kCallCodeObject;
}

2
src/compiler/backend/x64/code-generator-x64.cc
View File

@ -4680,7 +4680,7 @@ void CodeGenerator::PrepareForDeoptimizationExits(int deopt_count) {}
void CodeGenerator::IncrementStackAccessCounter(
InstructionOperand* source, InstructionOperand* destination) {
DCHECK(FLAG_trace_turbo_stack_accesses);
if (info()->IsNotOptimizedFunctionOrWasmFunction()) return;
if (!info()->IsOptimizing() && !info()->IsWasm()) return;
DCHECK_NOT_NULL(debug_name_);
auto IncrementCounter = [&](ExternalReference counter) {
__ incl(__ ExternalReferenceAsOperand(counter));

10
src/compiler/code-assembler.cc
View File

@ -46,7 +46,7 @@ static_assert(
CodeAssemblerState::CodeAssemblerState(
Isolate* isolate, Zone* zone, const CallInterfaceDescriptor& descriptor,
Code::Kind kind, const char* name, PoisoningMitigationLevel poisoning_level,
CodeKind kind, const char* name, PoisoningMitigationLevel poisoning_level,
int32_t builtin_index)
// TODO(rmcilroy): Should we use Linkage::GetBytecodeDispatchDescriptor for
// bytecode handlers?
@ -58,7 +58,7 @@ CodeAssemblerState::CodeAssemblerState(
kind, name, poisoning_level, builtin_index) {}
CodeAssemblerState::CodeAssemblerState(Isolate* isolate, Zone* zone,
int parameter_count, Code::Kind kind,
int parameter_count, CodeKind kind,
const char* name,
PoisoningMitigationLevel poisoning_level,
int32_t builtin_index)
@ -66,14 +66,14 @@ CodeAssemblerState::CodeAssemblerState(Isolate* isolate, Zone* zone,
isolate, zone,
Linkage::GetJSCallDescriptor(
zone, false, parameter_count,
(kind == Code::BUILTIN ? CallDescriptor::kPushArgumentCount
: CallDescriptor::kNoFlags) |
(kind == CodeKind::BUILTIN ? CallDescriptor::kPushArgumentCount
: CallDescriptor::kNoFlags) |
CallDescriptor::kCanUseRoots),
kind, name, poisoning_level, builtin_index) {}
CodeAssemblerState::CodeAssemblerState(Isolate* isolate, Zone* zone,
CallDescriptor* call_descriptor,
Code::Kind kind, const char* name,
CodeKind kind, const char* name,
PoisoningMitigationLevel poisoning_level,
int32_t builtin_index)
: raw_assembler_(new RawMachineAssembler(

8
src/compiler/code-assembler.h
View File

@ -1427,13 +1427,13 @@ class V8_EXPORT_PRIVATE CodeAssemblerState {
// |result_size| specifies the number of results returned by the stub.
// TODO(rmcilroy): move result_size to the CallInterfaceDescriptor.
CodeAssemblerState(Isolate* isolate, Zone* zone,
const CallInterfaceDescriptor& descriptor, Code::Kind kind,
const CallInterfaceDescriptor& descriptor, CodeKind kind,
const char* name, PoisoningMitigationLevel poisoning_level,
int32_t builtin_index = Builtins::kNoBuiltinId);
// Create with JSCall linkage.
CodeAssemblerState(Isolate* isolate, Zone* zone, int parameter_count,
Code::Kind kind, const char* name,
CodeKind kind, const char* name,
PoisoningMitigationLevel poisoning_level,
int32_t builtin_index = Builtins::kNoBuiltinId);
@ -1457,7 +1457,7 @@ class V8_EXPORT_PRIVATE CodeAssemblerState {
friend class ScopedExceptionHandler;
CodeAssemblerState(Isolate* isolate, Zone* zone,
CallDescriptor* call_descriptor, Code::Kind kind,
CallDescriptor* call_descriptor, CodeKind kind,
const char* name, PoisoningMitigationLevel poisoning_level,
int32_t builtin_index);
@ -1465,7 +1465,7 @@ class V8_EXPORT_PRIVATE CodeAssemblerState {
void PopExceptionHandler();
std::unique_ptr<RawMachineAssembler> raw_assembler_;
Code::Kind kind_;
CodeKind kind_;
const char* name_;
int32_t builtin_index_;
bool code_generated_;

6
src/compiler/linkage.cc
View File

@ -144,14 +144,14 @@ bool CallDescriptor::CanTailCall(const CallDescriptor* callee) const {
// TODO(jkummerow, sigurds): Arguably frame size calculation should be
// keyed on code/frame type, not on CallDescriptor kind. Think about a
// good way to organize this logic.
int CallDescriptor::CalculateFixedFrameSize(Code::Kind code_kind) const {
int CallDescriptor::CalculateFixedFrameSize(CodeKind code_kind) const {
switch (kind_) {
case kCallJSFunction:
return PushArgumentCount()
? OptimizedBuiltinFrameConstants::kFixedSlotCount
: StandardFrameConstants::kFixedSlotCount;
case kCallAddress:
if (code_kind == Code::C_WASM_ENTRY) {
if (code_kind == CodeKind::C_WASM_ENTRY) {
return CWasmEntryFrameConstants::kFixedSlotCount;
}
return CommonFrameConstants::kFixedSlotCountAboveFp +
@ -170,7 +170,7 @@ int CallDescriptor::CalculateFixedFrameSize(Code::Kind code_kind) const {
CallDescriptor* Linkage::ComputeIncoming(Zone* zone,
OptimizedCompilationInfo* info) {
DCHECK(!info->IsNotOptimizedFunctionOrWasmFunction());
DCHECK(info->IsOptimizing() || info->IsWasm());
if (!info->closure().is_null()) {
// If we are compiling a JS function, use a JS call descriptor,
// plus the receiver.

2
src/compiler/linkage.h
View File

@ -377,7 +377,7 @@ class V8_EXPORT_PRIVATE CallDescriptor final
bool CanTailCall(const CallDescriptor* callee) const;
int CalculateFixedFrameSize(Code::Kind code_kind) const;
int CalculateFixedFrameSize(CodeKind code_kind) const;
RegList AllocatableRegisters() const { return allocatable_registers_; }

72
src/compiler/pipeline.cc
View File

@ -154,7 +154,7 @@ class PipelineData {
codegen_zone_(codegen_zone_scope_.zone()),
broker_(new JSHeapBroker(
isolate_, info_->zone(), info_->trace_heap_broker(),
is_concurrent_inlining, info->native_context_independent(),
is_concurrent_inlining, info->IsNativeContextIndependent(),
info->DetachPersistentHandles())),
register_allocation_zone_scope_(zone_stats_,
kRegisterAllocationZoneName),
@ -879,7 +879,7 @@ void PrintCode(Isolate* isolate, Handle<Code> code,
}
#ifdef ENABLE_DISASSEMBLER
bool print_code =
const bool print_code =
FLAG_print_code ||
(info->IsOptimizing() && FLAG_print_opt_code &&
info->shared_info()->PassesFilter(FLAG_print_opt_code_filter));
@ -889,7 +889,7 @@ void PrintCode(Isolate* isolate, Handle<Code> code,
auto& os = tracing_scope.stream();
// Print the source code if available.
bool print_source = code->kind() == Code::OPTIMIZED_FUNCTION;
const bool print_source = info->IsOptimizing();
if (print_source) {
Handle<SharedFunctionInfo> shared = info->shared_info();
if (shared->script().IsScript() &&
@ -1046,8 +1046,7 @@ class PipelineCompilationJob final : public OptimizedCompilationJob {
PipelineCompilationJob(Isolate* isolate,
Handle<SharedFunctionInfo> shared_info,
Handle<JSFunction> function, BailoutId osr_offset,
JavaScriptFrame* osr_frame,
bool native_context_independent);
JavaScriptFrame* osr_frame, CodeKind code_kind);
~PipelineCompilationJob() final;
protected:
@ -1075,7 +1074,7 @@ class PipelineCompilationJob final : public OptimizedCompilationJob {
PipelineCompilationJob::PipelineCompilationJob(
Isolate* isolate, Handle<SharedFunctionInfo> shared_info,
Handle<JSFunction> function, BailoutId osr_offset,
JavaScriptFrame* osr_frame, bool native_context_independent)
JavaScriptFrame* osr_frame, CodeKind code_kind)
// Note that the OptimizedCompilationInfo is not initialized at the time
// we pass it to the CompilationJob constructor, but it is not
// dereferenced there.
@ -1084,7 +1083,7 @@ PipelineCompilationJob::PipelineCompilationJob(
kPipelineCompilationJobZoneName),
zone_stats_(function->GetIsolate()->allocator()),
compilation_info_(&zone_, function->GetIsolate(), shared_info, function,
native_context_independent),
code_kind),
pipeline_statistics_(CreatePipelineStatistics(
handle(Script::cast(shared_info->script()), isolate),
compilation_info(), function->GetIsolate(), &zone_stats_)),
@ -1127,14 +1126,14 @@ PipelineCompilationJob::Status PipelineCompilationJob::PrepareJobImpl(
return AbortOptimization(BailoutReason::kFunctionTooBig);
}
if (!FLAG_always_opt && !compilation_info()->native_context_independent()) {
if (!FLAG_always_opt && !compilation_info()->IsNativeContextIndependent()) {
compilation_info()->set_bailout_on_uninitialized();
}
if (FLAG_turbo_loop_peeling) {
compilation_info()->set_loop_peeling();
}
if (FLAG_turbo_inlining &&
!compilation_info()->native_context_independent()) {
!compilation_info()->IsNativeContextIndependent()) {
compilation_info()->set_inlining();
}
@ -1162,7 +1161,7 @@ PipelineCompilationJob::Status PipelineCompilationJob::PrepareJobImpl(
if (compilation_info()->closure()->raw_feedback_cell().map() ==
ReadOnlyRoots(isolate).one_closure_cell_map() &&
!compilation_info()->is_osr() &&
!compilation_info()->native_context_independent()) {
!compilation_info()->IsNativeContextIndependent()) {
compilation_info()->set_function_context_specializing();
data_.ChooseSpecializationContext();
}
@ -1248,7 +1247,7 @@ PipelineCompilationJob::Status PipelineCompilationJob::FinalizeJobImpl(
compilation_info()->SetCode(code);
Handle<NativeContext> context(compilation_info()->native_context(), isolate);
context->AddOptimizedCode(*code);
if (CodeKindCanDeoptimize(code->kind())) context->AddOptimizedCode(*code);
RegisterWeakObjectsInOptimizedCode(isolate, context, code);
return SUCCEEDED;
}
@ -1282,8 +1281,7 @@ class WasmHeapStubCompilationJob final : public OptimizedCompilationJob {
WasmHeapStubCompilationJob(Isolate* isolate, wasm::WasmEngine* wasm_engine,
CallDescriptor* call_descriptor,
std::unique_ptr<Zone> zone, Graph* graph,
Code::Kind kind,
std::unique_ptr<char[]> debug_name,
CodeKind kind, std::unique_ptr<char[]> debug_name,
const AssemblerOptions& options,
SourcePositionTable* source_positions)
// Note that the OptimizedCompilationInfo is not initialized at the time
@ -1327,7 +1325,7 @@ std::unique_ptr<OptimizedCompilationJob>
Pipeline::NewWasmHeapStubCompilationJob(
Isolate* isolate, wasm::WasmEngine* wasm_engine,
CallDescriptor* call_descriptor, std::unique_ptr<Zone> zone, Graph* graph,
Code::Kind kind, std::unique_ptr<char[]> debug_name,
CodeKind kind, std::unique_ptr<char[]> debug_name,
const AssemblerOptions& options, SourcePositionTable* source_positions) {
return std::make_unique<WasmHeapStubCompilationJob>(
isolate, wasm_engine, call_descriptor, std::move(zone), graph, kind,
@ -1355,7 +1353,7 @@ CompilationJob::Status WasmHeapStubCompilationJob::ExecuteJobImpl(
<< " using TurboFan" << std::endl;
}
if (info_.trace_turbo_graph()) { // Simple textual RPO.
StdoutStream{} << "-- wasm stub " << Code::Kind2String(info_.code_kind())
StdoutStream{} << "-- wasm stub " << CodeKindToString(info_.code_kind())
<< " graph -- " << std::endl
<< AsRPO(*data_.graph());
}
@ -1425,7 +1423,7 @@ struct GraphBuilderPhase {
if (data->info()->bailout_on_uninitialized()) {
flags |= BytecodeGraphBuilderFlag::kBailoutOnUninitialized;
}
if (data->info()->native_context_independent()) {
if (data->info()->IsNativeContextIndependent()) {
flags |= BytecodeGraphBuilderFlag::kNativeContextIndependent;
}
@ -1485,7 +1483,7 @@ struct InliningPhase {
AddReducer(data, &graph_reducer, &dead_code_elimination);
AddReducer(data, &graph_reducer, &checkpoint_elimination);
AddReducer(data, &graph_reducer, &common_reducer);
if (!data->info()->native_context_independent()) {
if (!data->info()->IsNativeContextIndependent()) {
AddReducer(data, &graph_reducer, &native_context_specialization);
AddReducer(data, &graph_reducer, &context_specialization);
}
@ -1628,7 +1626,7 @@ struct TypedLoweringPhase {
data->broker(), data->common(),
data->machine(), temp_zone);
AddReducer(data, &graph_reducer, &dead_code_elimination);
if (!data->info()->native_context_independent()) {
if (!data->info()->IsNativeContextIndependent()) {
AddReducer(data, &graph_reducer, &create_lowering);
}
AddReducer(data, &graph_reducer, &constant_folding_reducer);
@ -2445,11 +2443,11 @@ struct VerifyGraphPhase {
bool values_only = false) {
Verifier::CodeType code_type;
switch (data->info()->code_kind()) {
case Code::WASM_FUNCTION:
case Code::WASM_TO_CAPI_FUNCTION:
case Code::WASM_TO_JS_FUNCTION:
case Code::JS_TO_WASM_FUNCTION:
case Code::C_WASM_ENTRY:
case CodeKind::WASM_FUNCTION:
case CodeKind::WASM_TO_CAPI_FUNCTION:
case CodeKind::WASM_TO_JS_FUNCTION:
case CodeKind::JS_TO_WASM_FUNCTION:
case CodeKind::C_WASM_ENTRY:
code_type = Verifier::kWasm;
break;
default:
@ -2801,7 +2799,7 @@ int HashGraphForPGO(Graph* graph) {
MaybeHandle<Code> Pipeline::GenerateCodeForCodeStub(
Isolate* isolate, CallDescriptor* call_descriptor, Graph* graph,
JSGraph* jsgraph, SourcePositionTable* source_positions, Code::Kind kind,
JSGraph* jsgraph, SourcePositionTable* source_positions, CodeKind kind,
const char* debug_name, int32_t builtin_index,
PoisoningMitigationLevel poisoning_level, const AssemblerOptions& options,
const ProfileDataFromFile* profile_data) {
@ -2932,9 +2930,8 @@ std::ostream& operator<<(std::ostream& out, const BlockStartsAsJSON& s) {
// static
wasm::WasmCompilationResult Pipeline::GenerateCodeForWasmNativeStub(
wasm::WasmEngine* wasm_engine, CallDescriptor* call_descriptor,
MachineGraph* mcgraph, Code::Kind kind, int wasm_kind,
const char* debug_name, const AssemblerOptions& options,
SourcePositionTable* source_positions) {
MachineGraph* mcgraph, CodeKind kind, int wasm_kind, const char* debug_name,
const AssemblerOptions& options, SourcePositionTable* source_positions) {
Graph* graph = mcgraph->graph();
OptimizedCompilationInfo info(CStrVector(debug_name), graph->zone(), kind);
// Construct a pipeline for scheduling and code generation.
@ -2965,7 +2962,7 @@ wasm::WasmCompilationResult Pipeline::GenerateCodeForWasmNativeStub(
}
if (info.trace_turbo_graph()) { // Simple textual RPO.
StdoutStream{} << "-- wasm stub " << Code::Kind2String(kind) << " graph -- "
StdoutStream{} << "-- wasm stub " << CodeKindToString(kind) << " graph -- "
<< std::endl
<< AsRPO(*graph);
}
@ -3105,14 +3102,12 @@ MaybeHandle<Code> Pipeline::GenerateCodeForTesting(
// static
std::unique_ptr<OptimizedCompilationJob> Pipeline::NewCompilationJob(
Isolate* isolate, Handle<JSFunction> function, bool has_script,
BailoutId osr_offset, JavaScriptFrame* osr_frame,
bool native_context_independent) {
Isolate* isolate, Handle<JSFunction> function, CodeKind code_kind,
bool has_script, BailoutId osr_offset, JavaScriptFrame* osr_frame) {
Handle<SharedFunctionInfo> shared =
handle(function->shared(), function->GetIsolate());
return std::make_unique<PipelineCompilationJob>(isolate, shared, function,
osr_offset, osr_frame,
native_context_independent);
return std::make_unique<PipelineCompilationJob>(
isolate, shared, function, osr_offset, osr_frame, code_kind);
}
// static
@ -3244,7 +3239,7 @@ bool Pipeline::AllocateRegistersForTesting(const RegisterConfiguration* config,
bool use_mid_tier_register_allocator,
bool run_verifier) {
OptimizedCompilationInfo info(ArrayVector("testing"), sequence->zone(),
Code::STUB);
CodeKind::STUB);
ZoneStats zone_stats(sequence->isolate()->allocator());
PipelineData data(&zone_stats, &info, sequence->isolate(), sequence);
data.InitializeFrameData(nullptr);
@ -3320,10 +3315,9 @@ bool PipelineImpl::SelectInstructions(Linkage* linkage) {
<< "--------------------------------------------------\n";
}
Zone temp_zone(data->allocator(), kMachineGraphVerifierZoneName);
MachineGraphVerifier::Run(
data->graph(), data->schedule(), linkage,
data->info()->IsNotOptimizedFunctionOrWasmFunction(),
data->debug_name(), &temp_zone);
MachineGraphVerifier::Run(data->graph(), data->schedule(), linkage,
data->info()->IsStub(), data->debug_name(),
&temp_zone);
}
data->InitializeInstructionSequence(call_descriptor);

13
src/compiler/pipeline.h
View File

@ -46,10 +46,9 @@ class Pipeline : public AllStatic {
public:
// Returns a new compilation job for the given JavaScript function.
static std::unique_ptr<OptimizedCompilationJob> NewCompilationJob(
Isolate* isolate, Handle<JSFunction> function, bool has_script,
BailoutId osr_offset = BailoutId::None(),
JavaScriptFrame* osr_frame = nullptr,
bool native_context_independent = false);
Isolate* isolate, Handle<JSFunction> function, CodeKind code_kind,
bool has_script, BailoutId osr_offset = BailoutId::None(),
JavaScriptFrame* osr_frame = nullptr);
// Run the pipeline for the WebAssembly compilation info.
static void GenerateCodeForWasmFunction(
@ -62,7 +61,7 @@ class Pipeline : public AllStatic {
// Run the pipeline on a machine graph and generate code.
static wasm::WasmCompilationResult GenerateCodeForWasmNativeStub(
wasm::WasmEngine* wasm_engine, CallDescriptor* call_descriptor,
MachineGraph* mcgraph, Code::Kind kind, int wasm_kind,
MachineGraph* mcgraph, CodeKind kind, int wasm_kind,
const char* debug_name, const AssemblerOptions& assembler_options,
SourcePositionTable* source_positions = nullptr);
@ -70,14 +69,14 @@ class Pipeline : public AllStatic {
static std::unique_ptr<OptimizedCompilationJob> NewWasmHeapStubCompilationJob(
Isolate* isolate, wasm::WasmEngine* wasm_engine,
CallDescriptor* call_descriptor, std::unique_ptr<Zone> zone, Graph* graph,
Code::Kind kind, std::unique_ptr<char[]> debug_name,
CodeKind kind, std::unique_ptr<char[]> debug_name,
const AssemblerOptions& options,
SourcePositionTable* source_positions = nullptr);
// Run the pipeline on a machine graph and generate code.
static MaybeHandle<Code> GenerateCodeForCodeStub(
Isolate* isolate, CallDescriptor* call_descriptor, Graph* graph,
JSGraph* jsgraph, SourcePositionTable* source_positions, Code::Kind kind,
JSGraph* jsgraph, SourcePositionTable* source_positions, CodeKind kind,
const char* debug_name, int32_t builtin_index,
PoisoningMitigationLevel poisoning_level, const AssemblerOptions& options,
const ProfileDataFromFile* profile_data);

14
src/compiler/wasm-compiler.cc
View File

@ -6792,7 +6792,7 @@ std::unique_ptr<OptimizedCompilationJob> NewJSToWasmCompilationJob(
return Pipeline::NewWasmHeapStubCompilationJob(
isolate, wasm_engine, incoming, std::move(zone), graph,
Code::JS_TO_WASM_FUNCTION, std::move(name_buffer),
CodeKind::JS_TO_WASM_FUNCTION, std::move(name_buffer),
WasmAssemblerOptions());
}
@ -7019,7 +7019,7 @@ wasm::WasmCompilationResult CompileWasmMathIntrinsic(
}
wasm::WasmCompilationResult result = Pipeline::GenerateCodeForWasmNativeStub(
wasm_engine, call_descriptor, mcgraph, Code::WASM_FUNCTION,
wasm_engine, call_descriptor, mcgraph, CodeKind::WASM_FUNCTION,
wasm::WasmCode::kFunction, debug_name, WasmStubAssemblerOptions(),
source_positions);
return result;
@ -7078,7 +7078,7 @@ wasm::WasmCompilationResult CompileWasmImportCallWrapper(
incoming = GetI32WasmCallDescriptor(&zone, incoming);
}
wasm::WasmCompilationResult result = Pipeline::GenerateCodeForWasmNativeStub(
wasm_engine, incoming, mcgraph, Code::WASM_TO_JS_FUNCTION,
wasm_engine, incoming, mcgraph, CodeKind::WASM_TO_JS_FUNCTION,
wasm::WasmCode::kWasmToJsWrapper, func_name, WasmStubAssemblerOptions(),
source_position_table);
result.kind = wasm::WasmCompilationResult::kWasmToJsWrapper;
@ -7126,7 +7126,7 @@ wasm::WasmCode* CompileWasmCapiCallWrapper(wasm::WasmEngine* wasm_engine,
const char* debug_name = "WasmCapiCall";
wasm::WasmCompilationResult result = Pipeline::GenerateCodeForWasmNativeStub(
wasm_engine, call_descriptor, mcgraph, Code::WASM_TO_CAPI_FUNCTION,
wasm_engine, call_descriptor, mcgraph, CodeKind::WASM_TO_CAPI_FUNCTION,
wasm::WasmCode::kWasmToCapiWrapper, debug_name,
WasmStubAssemblerOptions(), source_positions);
std::unique_ptr<wasm::WasmCode> wasm_code = native_module->AddCode(
@ -7171,7 +7171,7 @@ MaybeHandle<Code> CompileJSToJSWrapper(Isolate* isolate,
std::unique_ptr<OptimizedCompilationJob> job(
Pipeline::NewWasmHeapStubCompilationJob(
isolate, isolate->wasm_engine(), incoming, std::move(zone), graph,
Code::JS_TO_JS_FUNCTION, std::move(name_buffer),
CodeKind::JS_TO_JS_FUNCTION, std::move(name_buffer),
AssemblerOptions::Default(isolate)));
if (job->ExecuteJob(isolate->counters()->runtime_call_stats()) ==
@ -7225,7 +7225,7 @@ Handle<Code> CompileCWasmEntry(Isolate* isolate, const wasm::FunctionSig* sig) {
std::unique_ptr<OptimizedCompilationJob> job(
Pipeline::NewWasmHeapStubCompilationJob(
isolate, isolate->wasm_engine(), incoming, std::move(zone), graph,
Code::C_WASM_ENTRY, std::move(name_buffer),
CodeKind::C_WASM_ENTRY, std::move(name_buffer),
AssemblerOptions::Default(isolate)));
CHECK_NE(job->ExecuteJob(isolate->counters()->runtime_call_stats()),
@ -7307,7 +7307,7 @@ wasm::WasmCompilationResult ExecuteTurbofanWasmCompilation(
InstructionSelector::AlignmentRequirements()));
OptimizedCompilationInfo info(GetDebugName(&zone, func_index), &zone,
Code::WASM_FUNCTION);
CodeKind::WASM_FUNCTION);
if (env->runtime_exception_support) {
info.set_wasm_runtime_exception_support();
}

2
src/debug/debug.cc
View File

@ -980,7 +980,7 @@ void Debug::PrepareStepOnThrow() {
// If it only contains one function, we already found the handler.
if (summaries.size() > 1) {
Handle<AbstractCode> code = summary.AsJavaScript().abstract_code();
CHECK_EQ(AbstractCode::INTERPRETED_FUNCTION, code->kind());
CHECK_EQ(CodeKind::INTERPRETED_FUNCTION, code->kind());
HandlerTable table(code->GetBytecodeArray());
int code_offset = summary.code_offset();
HandlerTable::CatchPrediction prediction;

26
src/deoptimizer/deoptimizer.cc
View File

@ -194,7 +194,7 @@ Code Deoptimizer::FindDeoptimizingCode(Address addr) {
Object element = native_context.DeoptimizedCodeListHead();
while (!element.IsUndefined(isolate)) {
Code code = Code::cast(element);
CHECK_EQ(code.kind(), Code::OPTIMIZED_FUNCTION);
CHECK(CodeKindCanDeoptimize(code.kind()));
if (code.contains(addr)) return code;
element = code.next_code_link();
}
@ -275,7 +275,7 @@ class ActivationsFinder : public ThreadVisitor {
for (StackFrameIterator it(isolate, top); !it.done(); it.Advance()) {
if (it.frame()->type() == StackFrame::OPTIMIZED) {
Code code = it.frame()->LookupCode();
if (code.kind() == Code::OPTIMIZED_FUNCTION &&
if (CodeKindCanDeoptimize(code.kind()) &&
code.marked_for_deoptimization()) {
codes_->erase(code);
// Obtain the trampoline to the deoptimizer call.
@ -331,7 +331,7 @@ void Deoptimizer::DeoptimizeMarkedCodeForContext(NativeContext native_context) {
// Turbofan deopt is checked when we are patching addresses on stack.
bool safe_if_deopt_triggered = safepoint.has_deoptimization_index();
bool is_builtin_code = code.kind() == Code::BUILTIN;
bool is_builtin_code = code.kind() == CodeKind::BUILTIN;
DCHECK(topmost_optimized_code.is_null() || safe_if_deopt_triggered ||
is_builtin_code);
if (topmost_optimized_code.is_null()) {
@ -352,7 +352,7 @@ void Deoptimizer::DeoptimizeMarkedCodeForContext(NativeContext native_context) {
Object element = native_context.OptimizedCodeListHead();
while (!element.IsUndefined(isolate)) {
Code code = Code::cast(element);
CHECK_EQ(code.kind(), Code::OPTIMIZED_FUNCTION);
CHECK(CodeKindCanDeoptimize(code.kind()));
Object next = code.next_code_link();
if (code.marked_for_deoptimization()) {
@ -442,7 +442,7 @@ void Deoptimizer::MarkAllCodeForContext(NativeContext native_context) {
Isolate* isolate = native_context.GetIsolate();
while (!element.IsUndefined(isolate)) {
Code code = Code::cast(element);
CHECK_EQ(code.kind(), Code::OPTIMIZED_FUNCTION);
CHECK(CodeKindCanDeoptimize(code.kind()));
code.set_marked_for_deoptimization(true);
element = code.next_code_link();
}
@ -457,7 +457,7 @@ void Deoptimizer::DeoptimizeFunction(JSFunction function, Code code) {
function.ResetIfBytecodeFlushed();
if (code.is_null()) code = function.code();
if (code.kind() == Code::OPTIMIZED_FUNCTION) {
if (CodeKindCanDeoptimize(code.kind())) {
// Mark the code for deoptimization and unlink any functions that also
// refer to that code. The code cannot be shared across native contexts,
// so we only need to search one.
@ -549,7 +549,7 @@ Deoptimizer::Deoptimizer(Isolate* isolate, JSFunction function,
DCHECK(AllowHeapAllocation::IsAllowed());
disallow_heap_allocation_ = new DisallowHeapAllocation();
#endif // DEBUG
CHECK_EQ(compiled_code_.kind(), Code::OPTIMIZED_FUNCTION);
CHECK(CodeKindCanDeoptimize(compiled_code_.kind()));
if (!compiled_code_.deopt_already_counted() &&
deopt_kind_ == DeoptimizeKind::kSoft) {
isolate->counters()->soft_deopts_executed()->Increment();
@ -608,8 +608,7 @@ void Deoptimizer::PrintFunctionName() {
if (function_.IsHeapObject() && function_.IsJSFunction()) {
function_.ShortPrint(trace_scope_->file());
} else {
PrintF(trace_scope_->file(), "%s",
Code::Kind2String(compiled_code_.kind()));
PrintF(trace_scope_->file(), "%s", CodeKindToString(compiled_code_.kind()));
}
}
@ -695,7 +694,7 @@ int Deoptimizer::GetDeoptimizedCodeCount(Isolate* isolate) {
Object element = native_context.DeoptimizedCodeListHead();
while (!element.IsUndefined(isolate)) {
Code code = Code::cast(element);
DCHECK_EQ(code.kind(), Code::OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(code.kind()));
if (!code.marked_for_deoptimization()) {
length++;
}
@ -1874,7 +1873,7 @@ unsigned Deoptimizer::ComputeInputFrameSize() const {
// function into account so we have to avoid double counting them.
unsigned fixed_size_above_fp = ComputeInputFrameAboveFpFixedSize();
unsigned result = fixed_size_above_fp + fp_to_sp_delta_;
DCHECK_EQ(compiled_code_.kind(), Code::OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(compiled_code_.kind()));
unsigned stack_slots = compiled_code_.stack_slots();
unsigned outgoing_size = 0;
// ComputeOutgoingArgumentSize(compiled_code_, bailout_id_);
@ -1908,8 +1907,9 @@ void Deoptimizer::EnsureCodeForDeoptimizationEntry(Isolate* isolate,
// Allocate the code as immovable since the entry addresses will be used
// directly and there is no support for relocating them.
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, Code::STUB).set_immovable().Build();
Handle<Code> code = Factory::CodeBuilder(isolate, desc, CodeKind::STUB)
.set_immovable()
.Build();
CHECK(isolate->heap()->IsImmovable(*code));
CHECK(data->deopt_entry_code(kind).is_null());

4
src/diagnostics/disassembler.cc
View File

@ -241,11 +241,11 @@ static void PrintRelocInfo(StringBuilder* out, Isolate* isolate,
out->AddFormatted(" ;; code:");
Code code = isolate->heap()->GcSafeFindCodeForInnerPointer(
relocinfo->target_address());
Code::Kind kind = code.kind();
CodeKind kind = code.kind();
if (code.is_builtin()) {
out->AddFormatted(" Builtin::%s", Builtins::name(code.builtin_index()));
} else {
out->AddFormatted(" %s", Code::Kind2String(kind));
out->AddFormatted(" %s", CodeKindToString(kind));
}
} else if (RelocInfo::IsWasmStubCall(rmode) && host.is_wasm_code()) {
// Host is isolate-independent, try wasm native module instead.

3
src/diagnostics/gdb-jit.cc
View File

@ -902,8 +902,7 @@ class CodeDescription {
LineInfo* lineinfo() const { return lineinfo_; }
bool is_function() const {
Code::Kind kind = code_.kind();
return kind == Code::OPTIMIZED_FUNCTION;
return CodeKindIsOptimizedJSFunction(code_.kind());
}
bool has_scope_info() const { return !shared_info_.is_null(); }

4
src/diagnostics/objects-debug.cc
View File

@ -1445,8 +1445,8 @@ void WasmInstanceObject::WasmInstanceObjectVerify(Isolate* isolate) {
void WasmExportedFunctionData::WasmExportedFunctionDataVerify(
Isolate* isolate) {
TorqueGeneratedClassVerifiers::WasmExportedFunctionDataVerify(*this, isolate);
CHECK(wrapper_code().kind() == Code::JS_TO_WASM_FUNCTION ||
wrapper_code().kind() == Code::C_WASM_ENTRY ||
CHECK(wrapper_code().kind() == CodeKind::JS_TO_WASM_FUNCTION ||
wrapper_code().kind() == CodeKind::C_WASM_ENTRY ||
(wrapper_code().is_builtin() &&
wrapper_code().builtin_index() == Builtins::kGenericJSToWasmWrapper));
}

8
src/diagnostics/perf-jit.cc
View File

@ -204,8 +204,8 @@ void PerfJitLogger::LogRecordedBuffer(
MaybeHandle<SharedFunctionInfo> maybe_shared, const char* name,
int length) {
if (FLAG_perf_basic_prof_only_functions &&
(abstract_code->kind() != AbstractCode::INTERPRETED_FUNCTION &&
abstract_code->kind() != AbstractCode::OPTIMIZED_FUNCTION)) {
(abstract_code->kind() != CodeKind::INTERPRETED_FUNCTION &&
abstract_code->kind() != CodeKind::OPTIMIZED_FUNCTION)) {
return;
}
@ -222,8 +222,8 @@ void PerfJitLogger::LogRecordedBuffer(
Handle<SharedFunctionInfo> shared;
if (FLAG_perf_prof && !maybe_shared.ToHandle(&shared)) {
// TODO(herhut): This currently breaks for js2wasm/wasm2js functions.
if (code->kind() != Code::JS_TO_WASM_FUNCTION &&
code->kind() != Code::WASM_TO_JS_FUNCTION) {
if (code->kind() != CodeKind::JS_TO_WASM_FUNCTION &&
code->kind() != CodeKind::WASM_TO_JS_FUNCTION) {
LogWriteDebugInfo(code, shared);
}
}

34
src/execution/frames.cc
View File

@ -568,7 +568,7 @@ StackFrame::Type StackFrame::ComputeType(const StackFrameIteratorBase* iterator,
Code code_obj = GetContainingCode(iterator->isolate(), pc);
if (!code_obj.is_null()) {
switch (code_obj.kind()) {
case Code::BUILTIN:
case CodeKind::BUILTIN:
if (StackFrame::IsTypeMarker(marker)) break;
if (code_obj.is_interpreter_trampoline_builtin()) {
return INTERPRETED;
@ -581,17 +581,18 @@ StackFrame::Type StackFrame::ComputeType(const StackFrameIteratorBase* iterator,
return OPTIMIZED;
}
return BUILTIN;
case Code::OPTIMIZED_FUNCTION:
case CodeKind::OPTIMIZED_FUNCTION:
case CodeKind::NATIVE_CONTEXT_INDEPENDENT:
return OPTIMIZED;
case Code::JS_TO_WASM_FUNCTION:
case CodeKind::JS_TO_WASM_FUNCTION:
return JS_TO_WASM;
case Code::JS_TO_JS_FUNCTION:
case CodeKind::JS_TO_JS_FUNCTION:
return STUB;
case Code::C_WASM_ENTRY:
case CodeKind::C_WASM_ENTRY:
return C_WASM_ENTRY;
case Code::WASM_FUNCTION:
case Code::WASM_TO_CAPI_FUNCTION:
case Code::WASM_TO_JS_FUNCTION:
case CodeKind::WASM_FUNCTION:
case CodeKind::WASM_TO_CAPI_FUNCTION:
case CodeKind::WASM_TO_JS_FUNCTION:
// Never appear as on-heap {Code} objects.
UNREACHABLE();
default:
@ -1078,7 +1079,7 @@ Address StubFrame::GetCallerStackPointer() const {
int StubFrame::LookupExceptionHandlerInTable() {
Code code = LookupCode();
DCHECK(code.is_turbofanned());
DCHECK_EQ(code.kind(), Code::BUILTIN);
DCHECK_EQ(code.kind(), CodeKind::BUILTIN);
HandlerTable table(code);
int pc_offset = static_cast<int>(pc() - code.InstructionStart());
return table.LookupReturn(pc_offset);
@ -1109,7 +1110,7 @@ Code JavaScriptFrame::unchecked_code() const { return function().code(); }
int OptimizedFrame::ComputeParametersCount() const {
Code code = LookupCode();
if (code.kind() == Code::BUILTIN) {
if (code.kind() == CodeKind::BUILTIN) {
return static_cast<int>(
Memory<intptr_t>(fp() + OptimizedBuiltinFrameConstants::kArgCOffset));
} else {
@ -1348,7 +1349,7 @@ FrameSummary::JavaScriptFrameSummary::JavaScriptFrameSummary(
is_constructor_(is_constructor),
parameters_(parameters, isolate) {
DCHECK(abstract_code.IsBytecodeArray() ||
Code::cast(abstract_code).kind() != Code::OPTIMIZED_FUNCTION);
!CodeKindIsOptimizedJSFunction(Code::cast(abstract_code).kind()));
}
void FrameSummary::EnsureSourcePositionsAvailable() {
@ -1511,7 +1512,7 @@ void OptimizedFrame::Summarize(std::vector<FrameSummary>* frames) const {
// Delegate to JS frame in absence of turbofan deoptimization.
// TODO(turbofan): Revisit once we support deoptimization across the board.
Code code = LookupCode();
if (code.kind() == Code::BUILTIN) {
if (code.kind() == CodeKind::BUILTIN) {
return JavaScriptFrame::Summarize(frames);
}
@ -1598,8 +1599,7 @@ int OptimizedFrame::LookupExceptionHandlerInTable(
// When the return pc has been replaced by a trampoline there won't be
// a handler for this trampoline. Thus we need to use the return pc that
// _used to be_ on the stack to get the right ExceptionHandler.
if (code.kind() == Code::OPTIMIZED_FUNCTION &&
code.marked_for_deoptimization()) {
if (CodeKindCanDeoptimize(code.kind()) && code.marked_for_deoptimization()) {
SafepointTable safepoints(code);
pc_offset = safepoints.find_return_pc(pc_offset);
}
@ -1620,7 +1620,7 @@ DeoptimizationData OptimizedFrame::GetDeoptimizationData(
code = isolate()->heap()->GcSafeFindCodeForInnerPointer(pc());
}
DCHECK(!code.is_null());
DCHECK(code.kind() == Code::OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(code.kind()));
SafepointEntry safepoint_entry = code.GetSafepointEntry(pc());
if (safepoint_entry.has_deoptimization_index()) {
@ -1634,7 +1634,7 @@ DeoptimizationData OptimizedFrame::GetDeoptimizationData(
#ifndef V8_REVERSE_JSARGS
Object OptimizedFrame::receiver() const {
Code code = LookupCode();
if (code.kind() == Code::BUILTIN) {
if (code.kind() == CodeKind::BUILTIN) {
intptr_t argc = static_cast<int>(
Memory<intptr_t>(fp() + OptimizedBuiltinFrameConstants::kArgCOffset));
intptr_t args_size =
@ -1656,7 +1656,7 @@ void OptimizedFrame::GetFunctions(
// Delegate to JS frame in absence of turbofan deoptimization.
// TODO(turbofan): Revisit once we support deoptimization across the board.
Code code = LookupCode();
if (code.kind() == Code::BUILTIN) {
if (code.kind() == CodeKind::BUILTIN) {
return JavaScriptFrame::GetFunctions(functions);
}

12
src/execution/isolate.cc
View File

@ -1827,7 +1827,7 @@ Object Isolate::UnwindAndFindHandler() {
// TODO(bmeurer): Turbofanned BUILTIN frames appear as OPTIMIZED,
// but do not have a code kind of OPTIMIZED_FUNCTION.
if (code.kind() == Code::OPTIMIZED_FUNCTION &&
if (CodeKindCanDeoptimize(code.kind()) &&
code.marked_for_deoptimization()) {
// If the target code is lazy deoptimized, we jump to the original
// return address, but we make a note that we are throwing, so
@ -1849,7 +1849,7 @@ Object Isolate::UnwindAndFindHandler() {
DCHECK_NULL(wasm_engine()->code_manager()->LookupCode(frame->pc()));
#endif // DEBUG
Code code = stub_frame->LookupCode();
if (!code.IsCode() || code.kind() != Code::BUILTIN ||
if (!code.IsCode() || code.kind() != CodeKind::BUILTIN ||
!code.has_handler_table() || !code.is_turbofanned()) {
break;
}
@ -1954,14 +1954,14 @@ HandlerTable::CatchPrediction PredictException(JavaScriptFrame* frame) {
for (size_t i = summaries.size(); i != 0; i--) {
const FrameSummary& summary = summaries[i - 1];
Handle<AbstractCode> code = summary.AsJavaScript().abstract_code();
if (code->IsCode() && code->kind() == AbstractCode::BUILTIN) {
if (code->IsCode() && code->kind() == CodeKind::BUILTIN) {
prediction = code->GetCode().GetBuiltinCatchPrediction();
if (prediction == HandlerTable::UNCAUGHT) continue;
return prediction;
}
// Must have been constructed from a bytecode array.
CHECK_EQ(AbstractCode::INTERPRETED_FUNCTION, code->kind());
CHECK_EQ(CodeKind::INTERPRETED_FUNCTION, code->kind());
int code_offset = summary.code_offset();
HandlerTable table(code->GetBytecodeArray());
int index = table.LookupRange(code_offset, nullptr, &prediction);
@ -2030,7 +2030,7 @@ Isolate::CatchType Isolate::PredictExceptionCatcher() {
case StackFrame::STUB: {
Handle<Code> code(frame->LookupCode(), this);
if (!code->IsCode() || code->kind() != Code::BUILTIN ||
if (!code->IsCode() || code->kind() != CodeKind::BUILTIN ||
!code->has_handler_table() || !code->is_turbofanned()) {
break;
}
@ -2536,7 +2536,7 @@ Handle<Object> Isolate::GetPromiseOnStackOnThrow() {
catch_prediction = PredictException(JavaScriptFrame::cast(frame));
} else if (frame->type() == StackFrame::STUB) {
Code code = frame->LookupCode();
if (!code.IsCode() || code.kind() != Code::BUILTIN ||
if (!code.IsCode() || code.kind() != CodeKind::BUILTIN ||
!code.has_handler_table() || !code.is_turbofanned()) {
continue;
}

2
src/execution/isolate.h
View File

@ -383,7 +383,7 @@ V8_EXPORT_PRIVATE void FreeCurrentEmbeddedBlob();
#define ISOLATE_INIT_DEBUG_ARRAY_LIST(V) \
V(CommentStatistic, paged_space_comments_statistics, \
CommentStatistic::kMaxComments + 1) \
V(int, code_kind_statistics, AbstractCode::NUMBER_OF_KINDS)
V(int, code_kind_statistics, kCodeKindCount)
#else
#define ISOLATE_INIT_DEBUG_ARRAY_LIST(V)

8
src/heap/code-stats.cc
View File

@ -41,7 +41,7 @@ void CodeStatistics::RecordCodeAndMetadataStatistics(HeapObject object,
#ifdef DEBUG
// Record code kind and code comment statistics.
isolate->code_kind_statistics()[abstract_code.kind()] +=
isolate->code_kind_statistics()[static_cast<int>(abstract_code.kind())] +=
abstract_code.Size();
CodeStatistics::CollectCodeCommentStatistics(object, isolate);
#endif
@ -86,10 +86,10 @@ void CodeStatistics::ReportCodeStatistics(Isolate* isolate) {
// Report code kind statistics
int* code_kind_statistics = isolate->code_kind_statistics();
PrintF("\n Code kind histograms: \n");
for (int i = 0; i < AbstractCode::NUMBER_OF_KINDS; i++) {
for (int i = 0; i < kCodeKindCount; i++) {
if (code_kind_statistics[i] > 0) {
PrintF(" %-20s: %10d bytes\n",
AbstractCode::Kind2String(static_cast<AbstractCode::Kind>(i)),
CodeKindToString(static_cast<CodeKind>(i)),
code_kind_statistics[i]);
}
}
@ -124,7 +124,7 @@ void CodeStatistics::ReportCodeStatistics(Isolate* isolate) {
void CodeStatistics::ResetCodeStatistics(Isolate* isolate) {
// Clear code kind statistics
int* code_kind_statistics = isolate->code_kind_statistics();
for (int i = 0; i < AbstractCode::NUMBER_OF_KINDS; i++) {
for (int i = 0; i < kCodeKindCount; i++) {
code_kind_statistics[i] = 0;
}

2
src/heap/factory.cc
View File

@ -86,7 +86,7 @@ int ComputeCodeObjectSize(const CodeDesc& desc) {
} // namespace
Factory::CodeBuilder::CodeBuilder(Isolate* isolate, const CodeDesc& desc,
Code::Kind kind)
CodeKind kind)
: isolate_(isolate),
code_desc_(desc),
kind_(kind),

4
src/heap/factory.h
View File

@ -795,7 +795,7 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
// which tries to gracefully handle allocation failure.
class V8_EXPORT_PRIVATE CodeBuilder final {
public:
CodeBuilder(Isolate* isolate, const CodeDesc& desc, Code::Kind kind);
CodeBuilder(Isolate* isolate, const CodeDesc& desc, CodeKind kind);
// Builds a new code object (fully initialized). All header fields of the
// returned object are immutable and the code object is write protected.
@ -875,7 +875,7 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
Isolate* const isolate_;
const CodeDesc& code_desc_;
const Code::Kind kind_;
const CodeKind kind_;
MaybeHandle<Object> self_reference_;
int32_t builtin_index_ = Builtins::kNoBuiltinId;

9
src/heap/object-stats.cc
View File

@ -1020,16 +1020,13 @@ void ObjectStatsCollectorImpl::RecordVirtualBytecodeArrayDetails(
namespace {
ObjectStats::VirtualInstanceType CodeKindToVirtualInstanceType(
Code::Kind kind) {
ObjectStats::VirtualInstanceType CodeKindToVirtualInstanceType(CodeKind kind) {
switch (kind) {
#define CODE_KIND_CASE(type) \
case Code::type: \
case CodeKind::type: \
return ObjectStats::type;
CODE_KIND_LIST(CODE_KIND_CASE)
#undef CODE_KIND_CASE
default:
UNREACHABLE();
}
UNREACHABLE();
}
@ -1049,7 +1046,7 @@ void ObjectStatsCollectorImpl::RecordVirtualCodeDetails(Code code) {
HeapObject::cast(source_position_table),
ObjectStats::SOURCE_POSITION_TABLE_TYPE);
}
if (code.kind() == Code::Kind::OPTIMIZED_FUNCTION) {
if (CodeKindIsOptimizedJSFunction(code.kind())) {
DeoptimizationData input_data =
DeoptimizationData::cast(code.deoptimization_data());
if (input_data.length() > 0) {

4
src/interpreter/interpreter-generator.cc
View File

@ -3112,8 +3112,8 @@ Handle<Code> GenerateBytecodeHandler(Isolate* isolate, const char* debug_name,
const AssemblerOptions& options) {
Zone zone(isolate->allocator(), ZONE_NAME, kCompressGraphZone);
compiler::CodeAssemblerState state(
isolate, &zone, InterpreterDispatchDescriptor{}, Code::BYTECODE_HANDLER,
debug_name,
isolate, &zone, InterpreterDispatchDescriptor{},
CodeKind::BYTECODE_HANDLER, debug_name,
FLAG_untrusted_code_mitigations
? PoisoningMitigationLevel::kPoisonCriticalOnly
: PoisoningMitigationLevel::kDontPoison,

4
src/interpreter/interpreter.cc
View File

@ -99,7 +99,7 @@ Code Interpreter::GetBytecodeHandler(Bytecode bytecode,
void Interpreter::SetBytecodeHandler(Bytecode bytecode,
OperandScale operand_scale, Code handler) {
DCHECK(handler.is_off_heap_trampoline());
DCHECK(handler.kind() == Code::BYTECODE_HANDLER);
DCHECK(handler.kind() == CodeKind::BYTECODE_HANDLER);
size_t index = GetDispatchTableIndex(bytecode, operand_scale);
dispatch_table_[index] = handler.InstructionStart();
}
@ -342,7 +342,7 @@ bool Interpreter::IsDispatchTableInitialized() const {
}
const char* Interpreter::LookupNameOfBytecodeHandler(const Code code) {
if (code.kind() == Code::BYTECODE_HANDLER) {
if (code.kind() == CodeKind::BYTECODE_HANDLER) {
return Builtins::name(code.builtin_index());
}
return nullptr;

47
src/logging/log.cc
View File

@ -75,9 +75,10 @@ static v8::CodeEventType GetCodeEventTypeForTag(
static const char* ComputeMarker(SharedFunctionInfo shared, AbstractCode code) {
switch (code.kind()) {
case AbstractCode::INTERPRETED_FUNCTION:
case CodeKind::INTERPRETED_FUNCTION:
return shared.optimization_disabled() ? "" : "~";
case AbstractCode::OPTIMIZED_FUNCTION:
case CodeKind::OPTIMIZED_FUNCTION:
case CodeKind::NATIVE_CONTEXT_INDEPENDENT:
return "*";
default:
return "";
@ -325,9 +326,7 @@ void PerfBasicLogger::LogRecordedBuffer(Handle<AbstractCode> code,
MaybeHandle<SharedFunctionInfo>,
const char* name, int length) {
if (FLAG_perf_basic_prof_only_functions &&
(code->kind() != AbstractCode::INTERPRETED_FUNCTION &&
code->kind() != AbstractCode::BUILTIN &&
code->kind() != AbstractCode::OPTIMIZED_FUNCTION)) {
CodeKindIsBuiltinOrJSFunction(code->kind())) {
return;
}
@ -1154,11 +1153,12 @@ namespace {
void AppendCodeCreateHeader(
Log::MessageBuilder& msg, // NOLINT(runtime/references)
CodeEventListener::LogEventsAndTags tag, AbstractCode::Kind kind,
uint8_t* address, int size, base::ElapsedTimer* timer) {
CodeEventListener::LogEventsAndTags tag, CodeKind kind, uint8_t* address,
int size, base::ElapsedTimer* timer) {
msg << kLogEventsNames[CodeEventListener::CODE_CREATION_EVENT]
<< Logger::kNext << kLogEventsNames[tag] << Logger::kNext << kind
<< Logger::kNext << timer->Elapsed().InMicroseconds() << Logger::kNext
<< Logger::kNext << kLogEventsNames[tag] << Logger::kNext
<< static_cast<int>(kind) << Logger::kNext
<< timer->Elapsed().InMicroseconds() << Logger::kNext
<< reinterpret_cast<void*>(address) << Logger::kNext << size
<< Logger::kNext;
}
@ -1315,7 +1315,7 @@ void Logger::CodeCreateEvent(LogEventsAndTags tag, const wasm::WasmCode* code,
if (!is_listening_to_code_events()) return;
if (!FLAG_log_code || !log_->IsEnabled()) return;
Log::MessageBuilder msg(log_.get());
AppendCodeCreateHeader(msg, tag, AbstractCode::Kind::WASM_FUNCTION,
AppendCodeCreateHeader(msg, tag, CodeKind::WASM_FUNCTION,
code->instructions().begin(),
code->instructions().length(), &timer_);
DCHECK(!name.empty());
@ -2056,20 +2056,21 @@ void ExistingCodeLogger::LogCodeObject(Object object) {
CodeEventListener::LogEventsAndTags tag = CodeEventListener::STUB_TAG;
const char* description = "Unknown code from before profiling";
switch (abstract_code->kind()) {
case AbstractCode::INTERPRETED_FUNCTION:
case AbstractCode::OPTIMIZED_FUNCTION:
case CodeKind::INTERPRETED_FUNCTION:
case CodeKind::OPTIMIZED_FUNCTION:
case CodeKind::NATIVE_CONTEXT_INDEPENDENT:
return; // We log this later using LogCompiledFunctions.
case AbstractCode::BYTECODE_HANDLER:
case CodeKind::BYTECODE_HANDLER:
return; // We log it later by walking the dispatch table.
case AbstractCode::STUB:
case CodeKind::STUB:
description = "STUB code";
tag = CodeEventListener::STUB_TAG;
break;
case AbstractCode::REGEXP:
case CodeKind::REGEXP:
description = "Regular expression code";
tag = CodeEventListener::REG_EXP_TAG;
break;
case AbstractCode::BUILTIN:
case CodeKind::BUILTIN:
if (Code::cast(object).is_interpreter_trampoline_builtin() &&
Code::cast(object) !=
*BUILTIN_CODE(isolate_, InterpreterEntryTrampoline)) {
@ -2079,32 +2080,30 @@ void ExistingCodeLogger::LogCodeObject(Object object) {
isolate_->builtins()->name(abstract_code->GetCode().builtin_index());
tag = CodeEventListener::BUILTIN_TAG;
break;
case AbstractCode::WASM_FUNCTION:
case CodeKind::WASM_FUNCTION:
description = "A Wasm function";
tag = CodeEventListener::FUNCTION_TAG;
break;
case AbstractCode::JS_TO_WASM_FUNCTION:
case CodeKind::JS_TO_WASM_FUNCTION:
description = "A JavaScript to Wasm adapter";
tag = CodeEventListener::STUB_TAG;
break;
case AbstractCode::JS_TO_JS_FUNCTION:
case CodeKind::JS_TO_JS_FUNCTION:
description = "A WebAssembly.Function adapter";
tag = CodeEventListener::STUB_TAG;
break;
case AbstractCode::WASM_TO_CAPI_FUNCTION:
case CodeKind::WASM_TO_CAPI_FUNCTION:
description = "A Wasm to C-API adapter";
tag = CodeEventListener::STUB_TAG;
break;
case AbstractCode::WASM_TO_JS_FUNCTION:
case CodeKind::WASM_TO_JS_FUNCTION:
description = "A Wasm to JavaScript adapter";
tag = CodeEventListener::STUB_TAG;
break;
case AbstractCode::C_WASM_ENTRY:
case CodeKind::C_WASM_ENTRY:
description = "A C to Wasm entry stub";
tag = CodeEventListener::STUB_TAG;
break;
case AbstractCode::NUMBER_OF_KINDS:
UNIMPLEMENTED();
}
CALL_CODE_EVENT_HANDLER(CodeCreateEvent(tag, abstract_code, description))
}

58
src/objects/code-inl.h
View File

@ -116,12 +116,8 @@ bool AbstractCode::contains(Address inner_pointer) {
return (address() <= inner_pointer) && (inner_pointer <= address() + Size());
}
AbstractCode::Kind AbstractCode::kind() {
if (IsCode()) {
return static_cast<AbstractCode::Kind>(GetCode().kind());
} else {
return INTERPRETED_FUNCTION;
}
CodeKind AbstractCode::kind() {
return IsCode() ? GetCode().kind() : CodeKind::INTERPRETED_FUNCTION;
}
Code AbstractCode::GetCode() { return Code::cast(*this); }
@ -345,16 +341,16 @@ void Code::CopyRelocInfoToByteArray(ByteArray dest, const CodeDesc& desc) {
int Code::CodeSize() const { return SizeFor(body_size()); }
Code::Kind Code::kind() const {
CodeKind Code::kind() const {
STATIC_ASSERT(FIELD_SIZE(kFlagsOffset) == kInt32Size);
return KindField::decode(ReadField<uint32_t>(kFlagsOffset));
}
void Code::initialize_flags(Kind kind, bool has_unwinding_info,
void Code::initialize_flags(CodeKind kind, bool has_unwinding_info,
bool is_turbofanned, int stack_slots,
bool is_off_heap_trampoline) {
CHECK(0 <= stack_slots && stack_slots < StackSlotsField::kMax);
DCHECK_NE(kind, NUMBER_OF_KINDS);
DCHECK(!CodeKindIsInterpretedJSFunction(kind));
uint32_t flags = HasUnwindingInfoField::encode(has_unwinding_info) |
KindField::encode(kind) |
IsTurbofannedField::encode(is_turbofanned) |
@ -378,12 +374,12 @@ inline bool Code::checks_optimization_marker() const {
(builtin_index() == Builtins::kCompileLazy ||
builtin_index() == Builtins::kInterpreterEntryTrampoline);
return checks_marker ||
(kind() == OPTIMIZED_FUNCTION && marked_for_deoptimization());
(CodeKindCanDeoptimize(kind()) && marked_for_deoptimization());
}
inline bool Code::has_tagged_params() const {
return kind() != JS_TO_WASM_FUNCTION && kind() != C_WASM_ENTRY &&
kind() != WASM_FUNCTION;
return kind() != CodeKind::JS_TO_WASM_FUNCTION &&
kind() != CodeKind::C_WASM_ENTRY && kind() != CodeKind::WASM_FUNCTION;
}
inline bool Code::has_unwinding_info() const {
@ -395,39 +391,39 @@ inline bool Code::is_turbofanned() const {
}
inline bool Code::can_have_weak_objects() const {
DCHECK(kind() == OPTIMIZED_FUNCTION);
DCHECK(CodeKindIsOptimizedJSFunction(kind()));
int32_t flags = code_data_container().kind_specific_flags();
return CanHaveWeakObjectsField::decode(flags);
}
inline void Code::set_can_have_weak_objects(bool value) {
DCHECK(kind() == OPTIMIZED_FUNCTION);
DCHECK(CodeKindIsOptimizedJSFunction(kind()));
int32_t previous = code_data_container().kind_specific_flags();
int32_t updated = CanHaveWeakObjectsField::update(previous, value);
code_data_container().set_kind_specific_flags(updated);
}
inline bool Code::is_promise_rejection() const {
DCHECK(kind() == BUILTIN);
DCHECK(kind() == CodeKind::BUILTIN);
int32_t flags = code_data_container().kind_specific_flags();
return IsPromiseRejectionField::decode(flags);
}
inline void Code::set_is_promise_rejection(bool value) {
DCHECK(kind() == BUILTIN);
DCHECK(kind() == CodeKind::BUILTIN);
int32_t previous = code_data_container().kind_specific_flags();
int32_t updated = IsPromiseRejectionField::update(previous, value);
code_data_container().set_kind_specific_flags(updated);
}
inline bool Code::is_exception_caught() const {
DCHECK(kind() == BUILTIN);
DCHECK(kind() == CodeKind::BUILTIN);
int32_t flags = code_data_container().kind_specific_flags();
return IsExceptionCaughtField::decode(flags);
}
inline void Code::set_is_exception_caught(bool value) {
DCHECK(kind() == BUILTIN);
DCHECK(kind() == CodeKind::BUILTIN);
int32_t previous = code_data_container().kind_specific_flags();
int32_t updated = IsExceptionCaughtField::update(previous, value);
code_data_container().set_kind_specific_flags(updated);
@ -457,13 +453,13 @@ void Code::set_builtin_index(int index) {
bool Code::is_builtin() const { return builtin_index() != -1; }
unsigned Code::inlined_bytecode_size() const {
DCHECK(kind() == OPTIMIZED_FUNCTION ||
DCHECK(CodeKindIsOptimizedJSFunction(kind()) ||
ReadField<unsigned>(kInlinedBytecodeSizeOffset) == 0);
return ReadField<unsigned>(kInlinedBytecodeSizeOffset);
}
void Code::set_inlined_bytecode_size(unsigned size) {
DCHECK(kind() == OPTIMIZED_FUNCTION || size == 0);
DCHECK(CodeKindIsOptimizedJSFunction(kind()) || size == 0);
WriteField<unsigned>(kInlinedBytecodeSizeOffset, size);
}
@ -477,13 +473,13 @@ int Code::stack_slots() const {
}
bool Code::marked_for_deoptimization() const {
DCHECK(kind() == OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(kind()));
int32_t flags = code_data_container().kind_specific_flags();
return MarkedForDeoptimizationField::decode(flags);
}
void Code::set_marked_for_deoptimization(bool flag) {
DCHECK(kind() == OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(kind()));
DCHECK_IMPLIES(flag, AllowDeoptimization::IsAllowed(GetIsolate()));
int32_t previous = code_data_container().kind_specific_flags();
int32_t updated = MarkedForDeoptimizationField::update(previous, flag);
@ -491,7 +487,7 @@ void Code::set_marked_for_deoptimization(bool flag) {
}
int Code::deoptimization_count() const {
DCHECK(kind() == OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(kind()));
int32_t flags = code_data_container().kind_specific_flags();
int count = DeoptCountField::decode(flags);
DCHECK_GE(count, 0);
@ -499,7 +495,7 @@ int Code::deoptimization_count() const {
}
void Code::increment_deoptimization_count() {
DCHECK(kind() == OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(kind()));
int32_t flags = code_data_container().kind_specific_flags();
int32_t count = DeoptCountField::decode(flags);
DCHECK_GE(count, 0);
@ -509,13 +505,13 @@ void Code::increment_deoptimization_count() {
}
bool Code::embedded_objects_cleared() const {
DCHECK(kind() == OPTIMIZED_FUNCTION);
DCHECK(CodeKindIsOptimizedJSFunction(kind()));
int32_t flags = code_data_container().kind_specific_flags();
return EmbeddedObjectsClearedField::decode(flags);
}
void Code::set_embedded_objects_cleared(bool flag) {
DCHECK(kind() == OPTIMIZED_FUNCTION);
DCHECK(CodeKindIsOptimizedJSFunction(kind()));
DCHECK_IMPLIES(flag, marked_for_deoptimization());
int32_t previous = code_data_container().kind_specific_flags();
int32_t updated = EmbeddedObjectsClearedField::update(previous, flag);
@ -523,21 +519,23 @@ void Code::set_embedded_objects_cleared(bool flag) {
}
bool Code::deopt_already_counted() const {
DCHECK(kind() == OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(kind()));
int32_t flags = code_data_container().kind_specific_flags();
return DeoptAlreadyCountedField::decode(flags);
}
void Code::set_deopt_already_counted(bool flag) {
DCHECK(kind() == OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(kind()));
DCHECK_IMPLIES(flag, AllowDeoptimization::IsAllowed(GetIsolate()));
int32_t previous = code_data_container().kind_specific_flags();
int32_t updated = DeoptAlreadyCountedField::update(previous, flag);
code_data_container().set_kind_specific_flags(updated);
}
bool Code::is_optimized_code() const { return kind() == OPTIMIZED_FUNCTION; }
bool Code::is_wasm_code() const { return kind() == WASM_FUNCTION; }
bool Code::is_optimized_code() const {
return CodeKindIsOptimizedJSFunction(kind());
}
bool Code::is_wasm_code() const { return kind() == CodeKind::WASM_FUNCTION; }
int Code::constant_pool_offset() const {
if (!FLAG_enable_embedded_constant_pool) return code_comments_offset();

22
src/objects/code-kind.cc Normal file
View File

@ -0,0 +1,22 @@
// Copyright 2020 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/objects/code-kind.h"
namespace v8 {
namespace internal {
const char* CodeKindToString(CodeKind kind) {
switch (kind) {
#define CASE(name) \
case CodeKind::name: \
return #name;
CODE_KIND_LIST(CASE)
#undef CASE
}
UNREACHABLE();
}
} // namespace internal
} // namespace v8

80
src/objects/code-kind.h Normal file
View File

@ -0,0 +1,80 @@
// Copyright 2020 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.
#ifndef V8_OBJECTS_CODE_KIND_H_
#define V8_OBJECTS_CODE_KIND_H_
#include "src/flags/flags.h"
namespace v8 {
namespace internal {
// TODO(jgruber,rmcilroy): Rename OPTIMIZED_FUNCTION once we've fully
// disambiguated Turboprop, Turbofan, and NCI code kinds.
// TODO(jgruber): Rename STUB to DEOPT_ENTRIES_OR_FOR_TESTING, or split it into
// DEOPT_ENTRIES and FOR_TESTING, or convert DEOPT_ENTRIES into a builtin.
#define CODE_KIND_LIST(V) \
V(OPTIMIZED_FUNCTION) \
V(BYTECODE_HANDLER) \
V(STUB) \
V(BUILTIN) \
V(REGEXP) \
V(WASM_FUNCTION) \
V(WASM_TO_CAPI_FUNCTION) \
V(WASM_TO_JS_FUNCTION) \
V(JS_TO_WASM_FUNCTION) \
V(JS_TO_JS_FUNCTION) \
V(C_WASM_ENTRY) \
V(INTERPRETED_FUNCTION) \
V(NATIVE_CONTEXT_INDEPENDENT)
enum class CodeKind {
#define DEFINE_CODE_KIND_ENUM(name) name,
CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
#undef DEFINE_CODE_KIND_ENUM
};
#define V(name) +1
static constexpr int kCodeKindCount = CODE_KIND_LIST(V);
#undef V
const char* CodeKindToString(CodeKind kind);
inline bool CodeKindIsInterpretedJSFunction(CodeKind kind) {
return kind == CodeKind::INTERPRETED_FUNCTION;
}
inline bool CodeKindIsNativeContextIndependentJSFunction(CodeKind kind) {
return kind == CodeKind::NATIVE_CONTEXT_INDEPENDENT;
}
inline bool CodeKindIsBuiltinOrJSFunction(CodeKind kind) {
return kind == CodeKind::BUILTIN || kind == CodeKind::INTERPRETED_FUNCTION ||
kind == CodeKind::OPTIMIZED_FUNCTION ||
kind == CodeKind::NATIVE_CONTEXT_INDEPENDENT;
}
inline bool CodeKindIsOptimizedJSFunction(CodeKind kind) {
return kind == CodeKind::OPTIMIZED_FUNCTION ||
kind == CodeKind::NATIVE_CONTEXT_INDEPENDENT;
}
inline bool CodeKindCanDeoptimize(CodeKind kind) {
// Even though NCI code does not deopt by itself at the time of writing,
// tests may trigger deopts manually and thus we cannot make a narrower
// distinction here.
return CodeKindIsOptimizedJSFunction(kind);
}
inline CodeKind CodeKindForTopTier() {
return FLAG_turbo_nci_as_highest_tier ? CodeKind::NATIVE_CONTEXT_INDEPENDENT
: CodeKind::OPTIMIZED_FUNCTION;
}
inline CodeKind CodeKindForOSR() { return CodeKind::OPTIMIZED_FUNCTION; }
} // namespace internal
} // namespace v8
#endif // V8_OBJECTS_CODE_KIND_H_

34
src/objects/code.cc
View File

@ -226,27 +226,6 @@ bool Code::CanDeoptAt(Address pc) {
return false;
}
// Identify kind of code.
const char* Code::Kind2String(Kind kind) {
switch (kind) {
#define CASE(name) \
case name: \
return #name;
CODE_KIND_LIST(CASE)
#undef CASE
case NUMBER_OF_KINDS:
break;
}
UNREACHABLE();
}
// Identify kind of code.
const char* AbstractCode::Kind2String(Kind kind) {
DCHECK_NE(kind, AbstractCode::NUMBER_OF_KINDS);
if (kind == AbstractCode::INTERPRETED_FUNCTION) return "INTERPRETED_FUNCTION";
return Code::Kind2String(static_cast<Code::Kind>(kind));
}
bool Code::IsIsolateIndependent(Isolate* isolate) {
static constexpr int kModeMask =
RelocInfo::AllRealModesMask() &
@ -394,7 +373,7 @@ Code Code::OptimizedCodeIterator::Next() {
}
current_code_ = next.IsUndefined(isolate_) ? Code() : Code::cast(next);
} while (current_code_.is_null());
DCHECK_EQ(Code::OPTIMIZED_FUNCTION, current_code_.kind());
DCHECK(CodeKindCanDeoptimize(current_code_.kind()));
return current_code_;
}
@ -421,7 +400,7 @@ SharedFunctionInfo DeoptimizationData::GetInlinedFunction(int index) {
#ifdef ENABLE_DISASSEMBLER
const char* Code::GetName(Isolate* isolate) const {
if (kind() == BYTECODE_HANDLER) {
if (kind() == CodeKind::BYTECODE_HANDLER) {
return isolate->interpreter()->LookupNameOfBytecodeHandler(*this);
} else {
// There are some handlers and ICs that we can also find names for with
@ -689,14 +668,14 @@ inline void DisassembleCodeRange(Isolate* isolate, std::ostream& os, Code code,
void Code::Disassemble(const char* name, std::ostream& os, Isolate* isolate,
Address current_pc) {
os << "kind = " << Kind2String(kind()) << "\n";
os << "kind = " << CodeKindToString(kind()) << "\n";
if (name == nullptr) {
name = GetName(isolate);
}
if ((name != nullptr) && (name[0] != '\0')) {
os << "name = " << name << "\n";
}
if (kind() == OPTIMIZED_FUNCTION) {
if (CodeKindIsOptimizedJSFunction(kind())) {
os << "stack_slots = " << stack_slots() << "\n";
}
os << "compiler = " << (is_turbofanned() ? "turbofan" : "unknown") << "\n";
@ -761,7 +740,7 @@ void Code::Disassemble(const char* name, std::ostream& os, Isolate* isolate,
}
}
if (kind() == OPTIMIZED_FUNCTION) {
if (CodeKindCanDeoptimize(kind())) {
DeoptimizationData data =
DeoptimizationData::cast(this->deoptimization_data());
data.DeoptimizationDataPrint(os);
@ -795,9 +774,8 @@ void Code::Disassemble(const char* name, std::ostream& os, Isolate* isolate,
if (has_handler_table()) {
HandlerTable table(*this);
os << "Handler Table (size = " << table.NumberOfReturnEntries() << ")\n";
if (kind() == OPTIMIZED_FUNCTION) {
if (CodeKindIsOptimizedJSFunction(kind()))
table.HandlerTableReturnPrint(os);
}
os << "\n";
}

77
src/objects/code.h
View File

@ -7,6 +7,7 @@
#include "src/base/bit-field.h"
#include "src/codegen/handler-table.h"
#include "src/objects/code-kind.h"
#include "src/objects/contexts.h"
#include "src/objects/fixed-array.h"
#include "src/objects/heap-object.h"
@ -77,32 +78,6 @@ class Code : public HeapObject {
// cache state, and arguments count.
using Flags = uint32_t;
// TODO(jgruber,rmcilroy): Rename OPTIMIZED_FUNCTION once we've fully
// disambiguated Turboprop, Turbofan, and NCI code kinds.
// TODO(jgruber): Rename STUB to DEOPT_ENTRIES_OR_FOR_TESTING, or split it into
// DEOPT_ENTRIES and FOR_TESTING, or convert DEOPT_ENTRIES into a builtin.
#define CODE_KIND_LIST(V) \
V(OPTIMIZED_FUNCTION) \
V(BYTECODE_HANDLER) \
V(STUB) \
V(BUILTIN) \
V(REGEXP) \
V(WASM_FUNCTION) \
V(WASM_TO_CAPI_FUNCTION) \
V(WASM_TO_JS_FUNCTION) \
V(JS_TO_WASM_FUNCTION) \
V(JS_TO_JS_FUNCTION) \
V(C_WASM_ENTRY)
enum Kind {
#define DEFINE_CODE_KIND_ENUM(name) name,
CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
#undef DEFINE_CODE_KIND_ENUM
NUMBER_OF_KINDS
};
static const char* Kind2String(Kind kind);
#ifdef ENABLE_DISASSEMBLER
const char* GetName(Isolate* isolate) const;
V8_EXPORT_PRIVATE void Disassemble(const char* name, std::ostream& os,
@ -151,7 +126,7 @@ class Code : public HeapObject {
inline int relocation_size() const;
// [kind]: Access to specific code kind.
inline Kind kind() const;
inline CodeKind kind() const;
inline bool is_optimized_code() const;
inline bool is_wasm_code() const;
@ -166,12 +141,12 @@ class Code : public HeapObject {
// Tells whether the outgoing parameters of this code are tagged pointers.
inline bool has_tagged_params() const;
// [is_turbofanned]: For kind STUB or OPTIMIZED_FUNCTION, tells whether the
// code object was generated by the TurboFan optimizing compiler.
// [is_turbofanned]: Tells whether the code object was generated by the
// TurboFan optimizing compiler.
inline bool is_turbofanned() const;
// [can_have_weak_objects]: For kind OPTIMIZED_FUNCTION, tells whether the
// embedded objects in code should be treated weakly.
// [can_have_weak_objects]: If CodeKindIsOptimizedJSFunction(kind), tells
// whether the embedded objects in code should be treated weakly.
inline bool can_have_weak_objects() const;
inline void set_can_have_weak_objects(bool value);
@ -224,24 +199,26 @@ class Code : public HeapObject {
// The size of the executable instruction area, without embedded metadata.
int ExecutableInstructionSize() const;
// [marked_for_deoptimization]: For kind OPTIMIZED_FUNCTION tells whether
// [marked_for_deoptimization]: If CodeKindCanDeoptimize(kind), tells whether
// the code is going to be deoptimized.
inline bool marked_for_deoptimization() const;
inline void set_marked_for_deoptimization(bool flag);
// [deoptimzation_count]: In turboprop we retain the deoptimized code on soft
// deopts for a certain number of soft deopts. This field keeps track of
// number of deoptimizations we have seen so far.
// [deoptimization_count]: If CodeKindCanDeoptimize(kind). In turboprop we
// retain the deoptimized code on soft deopts for a certain number of soft
// deopts. This field keeps track of the number of deoptimizations we have
// seen so far.
inline int deoptimization_count() const;
inline void increment_deoptimization_count();
// [embedded_objects_cleared]: For kind OPTIMIZED_FUNCTION tells whether
// the embedded objects in the code marked for deoptimization were cleared.
// Note that embedded_objects_cleared() implies marked_for_deoptimization().
// [embedded_objects_cleared]: If CodeKindIsOptimizedJSFunction(kind), tells
// whether the embedded objects in the code marked for deoptimization were
// cleared. Note that embedded_objects_cleared() implies
// marked_for_deoptimization().
inline bool embedded_objects_cleared() const;
inline void set_embedded_objects_cleared(bool flag);
// [deopt_already_counted]: For kind OPTIMIZED_FUNCTION tells whether
// [deopt_already_counted]: If CodeKindCanDeoptimize(kind), tells whether
// the code was already deoptimized.
inline bool deopt_already_counted() const;
inline void set_deopt_already_counted(bool flag);
@ -282,7 +259,7 @@ class Code : public HeapObject {
inline void clear_padding();
// Initialize the flags field. Similar to clear_padding above this ensure that
// the snapshot content is deterministic.
inline void initialize_flags(Kind kind, bool has_unwinding_info,
inline void initialize_flags(CodeKind kind, bool has_unwinding_info,
bool is_turbofanned, int stack_slots,
bool is_off_heap_trampoline);
@ -495,18 +472,18 @@ class Code : public HeapObject {
// Flags layout. base::BitField<type, shift, size>.
#define CODE_FLAGS_BIT_FIELDS(V, _) \
V(HasUnwindingInfoField, bool, 1, _) \
V(KindField, Kind, 4, _) \
V(KindField, CodeKind, 4, _) \
V(IsTurbofannedField, bool, 1, _) \
V(StackSlotsField, int, 24, _) \
V(IsOffHeapTrampoline, bool, 1, _)
DEFINE_BIT_FIELDS(CODE_FLAGS_BIT_FIELDS)
#undef CODE_FLAGS_BIT_FIELDS
STATIC_ASSERT(NUMBER_OF_KINDS <= KindField::kMax);
STATIC_ASSERT(kCodeKindCount <= KindField::kNumValues);
STATIC_ASSERT(CODE_FLAGS_BIT_FIELDS_Ranges::kBitsCount == 31);
STATIC_ASSERT(CODE_FLAGS_BIT_FIELDS_Ranges::kBitsCount <=
FIELD_SIZE(kFlagsOffset) * kBitsPerByte);
// KindSpecificFlags layout (STUB, BUILTIN, and OPTIMIZED_FUNCTION).
// KindSpecificFlags layout.
#define CODE_KIND_SPECIFIC_FLAGS_BIT_FIELDS(V, _) \
V(MarkedForDeoptimizationField, bool, 1, _) \
V(EmbeddedObjectsClearedField, bool, 1, _) \
@ -556,16 +533,6 @@ class Code::OptimizedCodeIterator {
class AbstractCode : public HeapObject {
public:
NEVER_READ_ONLY_SPACE
// All code kinds and INTERPRETED_FUNCTION.
enum Kind {
#define DEFINE_CODE_KIND_ENUM(name) name,
CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
#undef DEFINE_CODE_KIND_ENUM
INTERPRETED_FUNCTION,
NUMBER_OF_KINDS
};
static const char* Kind2String(Kind kind);
int SourcePosition(int offset);
int SourceStatementPosition(int offset);
@ -607,8 +574,8 @@ class AbstractCode : public HeapObject {
// Returns true if pc is inside this object's instructions.
inline bool contains(Address pc);
// Returns the AbstractCode::Kind of the code.
inline Kind kind();
// Returns the kind of the code.
inline CodeKind kind();
// Calculate the size of the code object to report for log events. This takes
// the layout of the code object into account.

2
src/objects/contexts.cc
View File

@ -411,7 +411,7 @@ Handle<Object> Context::Lookup(Handle<Context> context, Handle<String> name,
}
void NativeContext::AddOptimizedCode(Code code) {
DCHECK(code.kind() == Code::OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(code.kind()));
DCHECK(code.next_code_link().IsUndefined());
code.set_next_code_link(get(OPTIMIZED_CODE_LIST));
set(OPTIMIZED_CODE_LIST, code, UPDATE_WEAK_WRITE_BARRIER);

2
src/objects/feedback-vector.cc
View File

@ -376,7 +376,7 @@ void FeedbackVector::AddToVectorsForProfilingTools(
// static
void FeedbackVector::SetOptimizedCode(Handle<FeedbackVector> vector,
Handle<Code> code) {
DCHECK_EQ(code->kind(), Code::OPTIMIZED_FUNCTION);
DCHECK(CodeKindIsOptimizedJSFunction(code->kind()));
vector->set_optimized_code_weak_or_smi(HeapObjectReference::Weak(*code));
}

4
src/objects/js-function.cc
View File

@ -43,7 +43,7 @@ ClosureFeedbackCellArray JSFunction::closure_feedback_cell_array() const {
// TODO(jupvfranco): rename this function. Maybe RunOptimizedCode,
// or IsValidOptimizedCode.
bool JSFunction::IsOptimized() {
return is_compiled() && code().kind() == Code::OPTIMIZED_FUNCTION &&
return is_compiled() && CodeKindIsOptimizedJSFunction(code().kind()) &&
!code().marked_for_deoptimization();
}
@ -66,7 +66,7 @@ void JSFunction::ClearOptimizationMarker() {
// interpreted on its next activation, and already doesn't count as IsOptimized.
bool JSFunction::IsInterpreted() {
return is_compiled() && (code().is_interpreter_trampoline_builtin() ||
(code().kind() == Code::OPTIMIZED_FUNCTION &&
(CodeKindIsOptimizedJSFunction(code().kind()) &&
code().marked_for_deoptimization()));
}

2
src/objects/objects.cc
View File

@ -2059,7 +2059,7 @@ void HeapObject::HeapObjectShortPrint(std::ostream& os) { // NOLINT
}
case CODE_TYPE: {
Code code = Code::cast(*this);
os << "<Code " << Code::Kind2String(code.kind());
os << "<Code " << CodeKindToString(code.kind());
if (code.is_builtin()) {
os << " " << Builtins::name(code.builtin_index());
}

2
src/objects/osr-optimized-code-cache.cc
View File

@ -19,7 +19,7 @@ void OSROptimizedCodeCache::AddOptimizedCode(
Handle<NativeContext> native_context, Handle<SharedFunctionInfo> shared,
Handle<Code> code, BailoutId osr_offset) {
DCHECK(!osr_offset.IsNone());
DCHECK_EQ(code->kind(), Code::OPTIMIZED_FUNCTION);
DCHECK(CodeKindIsOptimizedJSFunction(code->kind()));
STATIC_ASSERT(kEntryLength == 3);
Isolate* isolate = native_context->GetIsolate();
DCHECK(!isolate->serializer_enabled());

4
src/objects/shared-function-info.cc
View File

@ -432,8 +432,8 @@ void SharedFunctionInfo::DisableOptimization(BailoutReason reason) {
set_flags(DisabledOptimizationReasonBits::update(flags(), reason));
// Code should be the lazy compilation stub or else interpreted.
DCHECK(abstract_code().kind() == AbstractCode::INTERPRETED_FUNCTION ||
abstract_code().kind() == AbstractCode::BUILTIN);
DCHECK(abstract_code().kind() == CodeKind::INTERPRETED_FUNCTION ||
abstract_code().kind() == CodeKind::BUILTIN);
PROFILE(GetIsolate(),
CodeDisableOptEvent(handle(abstract_code(), GetIsolate()),
handle(*this, GetIsolate())));

2
src/profiler/heap-snapshot-generator.cc
View File

@ -1107,7 +1107,7 @@ void V8HeapExplorer::ExtractSharedFunctionInfoReferences(
} else {
TagObject(shared.GetCode(),
names_->GetFormatted("(%s code)",
Code::Kind2String(shared.GetCode().kind())));
CodeKindToString(shared.GetCode().kind())));
}
if (shared.name_or_scope_info().IsScopeInfo()) {

7
src/regexp/arm/regexp-macro-assembler-arm.cc
View File

@ -903,9 +903,10 @@ Handle<HeapObject> RegExpMacroAssemblerARM::GetCode(Handle<String> source) {
CodeDesc code_desc;
masm_->GetCode(isolate(), &code_desc);
Handle<Code> code = Factory::CodeBuilder(isolate(), code_desc, Code::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
Handle<Code> code =
Factory::CodeBuilder(isolate(), code_desc, CodeKind::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
PROFILE(masm_->isolate(),
RegExpCodeCreateEvent(Handle<AbstractCode>::cast(code), source));
return Handle<HeapObject>::cast(code);

7
src/regexp/arm64/regexp-macro-assembler-arm64.cc
View File

@ -1096,9 +1096,10 @@ Handle<HeapObject> RegExpMacroAssemblerARM64::GetCode(Handle<String> source) {
CodeDesc code_desc;
masm_->GetCode(isolate(), &code_desc);
Handle<Code> code = Factory::CodeBuilder(isolate(), code_desc, Code::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
Handle<Code> code =
Factory::CodeBuilder(isolate(), code_desc, CodeKind::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
PROFILE(masm_->isolate(),
RegExpCodeCreateEvent(Handle<AbstractCode>::cast(code), source));
return Handle<HeapObject>::cast(code);

7
src/regexp/ia32/regexp-macro-assembler-ia32.cc
View File

@ -942,9 +942,10 @@ Handle<HeapObject> RegExpMacroAssemblerIA32::GetCode(Handle<String> source) {
CodeDesc code_desc;
masm_->GetCode(masm_->isolate(), &code_desc);
Handle<Code> code = Factory::CodeBuilder(isolate(), code_desc, Code::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
Handle<Code> code =
Factory::CodeBuilder(isolate(), code_desc, CodeKind::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
PROFILE(masm_->isolate(),
RegExpCodeCreateEvent(Handle<AbstractCode>::cast(code), source));
return Handle<HeapObject>::cast(code);

7
src/regexp/mips/regexp-macro-assembler-mips.cc
View File

@ -914,9 +914,10 @@ Handle<HeapObject> RegExpMacroAssemblerMIPS::GetCode(Handle<String> source) {
CodeDesc code_desc;
masm_->GetCode(isolate(), &code_desc);
Handle<Code> code = Factory::CodeBuilder(isolate(), code_desc, Code::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
Handle<Code> code =
Factory::CodeBuilder(isolate(), code_desc, CodeKind::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
LOG(masm_->isolate(),
RegExpCodeCreateEvent(Handle<AbstractCode>::cast(code), source));
return Handle<HeapObject>::cast(code);

7
src/regexp/mips64/regexp-macro-assembler-mips64.cc
View File

@ -950,9 +950,10 @@ Handle<HeapObject> RegExpMacroAssemblerMIPS::GetCode(Handle<String> source) {
CodeDesc code_desc;
masm_->GetCode(isolate(), &code_desc);
Handle<Code> code = Factory::CodeBuilder(isolate(), code_desc, Code::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
Handle<Code> code =
Factory::CodeBuilder(isolate(), code_desc, CodeKind::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
LOG(masm_->isolate(),
RegExpCodeCreateEvent(Handle<AbstractCode>::cast(code), source));
return Handle<HeapObject>::cast(code);

7
src/regexp/ppc/regexp-macro-assembler-ppc.cc
View File

@ -956,9 +956,10 @@ Handle<HeapObject> RegExpMacroAssemblerPPC::GetCode(Handle<String> source) {
CodeDesc code_desc;
masm_->GetCode(isolate(), &code_desc);
Handle<Code> code = Factory::CodeBuilder(isolate(), code_desc, Code::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
Handle<Code> code =
Factory::CodeBuilder(isolate(), code_desc, CodeKind::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
PROFILE(masm_->isolate(),
RegExpCodeCreateEvent(Handle<AbstractCode>::cast(code), source));
return Handle<HeapObject>::cast(code);

7
src/regexp/s390/regexp-macro-assembler-s390.cc
View File

@ -951,9 +951,10 @@ Handle<HeapObject> RegExpMacroAssemblerS390::GetCode(Handle<String> source) {
CodeDesc code_desc;
masm_->GetCode(isolate(), &code_desc);
Handle<Code> code = Factory::CodeBuilder(isolate(), code_desc, Code::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
Handle<Code> code =
Factory::CodeBuilder(isolate(), code_desc, CodeKind::REGEXP)
.set_self_reference(masm_->CodeObject())
.Build();
PROFILE(masm_->isolate(),
RegExpCodeCreateEvent(Handle<AbstractCode>::cast(code), source));
return Handle<HeapObject>::cast(code);

2
src/regexp/x64/regexp-macro-assembler-x64.cc
View File

@ -1005,7 +1005,7 @@ Handle<HeapObject> RegExpMacroAssemblerX64::GetCode(Handle<String> source) {
CodeDesc code_desc;
Isolate* isolate = this->isolate();
masm_.GetCode(isolate, &code_desc);
Handle<Code> code = Factory::CodeBuilder(isolate, code_desc, Code::REGEXP)
Handle<Code> code = Factory::CodeBuilder(isolate, code_desc, CodeKind::REGEXP)
.set_self_reference(masm_.CodeObject())
.Build();
PROFILE(isolate,

10
src/runtime/runtime-compiler.cc
View File

@ -65,12 +65,12 @@ Object CompileOptimized(Isolate* isolate, Handle<JSFunction> function,
if (check.JsHasOverflowed(kStackSpaceRequiredForCompilation * KB)) {
return isolate->StackOverflow();
}
if (!Compiler::CompileOptimized(function, mode, DefaultCompilationTarget())) {
if (!Compiler::CompileOptimized(function, mode, CodeKindForTopTier())) {
return ReadOnlyRoots(isolate).exception();
}
if (ShouldSpawnExtraNativeContextIndependentCompilationJob()) {
if (!Compiler::CompileOptimized(
function, mode, CompilationTarget::kNativeContextIndependent)) {
if (!Compiler::CompileOptimized(function, mode,
CodeKind::NATIVE_CONTEXT_INDEPENDENT)) {
return ReadOnlyRoots(isolate).exception();
}
}
@ -164,7 +164,7 @@ RUNTIME_FUNCTION(Runtime_NotifyDeoptimized) {
HandleScope scope(isolate);
DCHECK_EQ(0, args.length());
Deoptimizer* deoptimizer = Deoptimizer::Grab(isolate);
DCHECK(deoptimizer->compiled_code()->kind() == Code::OPTIMIZED_FUNCTION);
DCHECK(CodeKindCanDeoptimize(deoptimizer->compiled_code()->kind()));
DCHECK(deoptimizer->compiled_code()->is_turbofanned());
DCHECK(AllowHeapAllocation::IsAllowed());
DCHECK(isolate->context().is_null());
@ -284,7 +284,7 @@ RUNTIME_FUNCTION(Runtime_CompileForOnStackReplacement) {
// Check whether we ended up with usable optimized code.
Handle<Code> result;
if (maybe_result.ToHandle(&result) &&
result->kind() == Code::OPTIMIZED_FUNCTION) {
CodeKindIsOptimizedJSFunction(result->kind())) {
DeoptimizationData data =
DeoptimizationData::cast(result->deoptimization_data());

6
src/runtime/runtime-test.cc
View File

@ -489,8 +489,8 @@ RUNTIME_FUNCTION(Runtime_NeverOptimizeFunction) {
if (!function_object->IsJSFunction()) return CrashUnlessFuzzing(isolate);
Handle<JSFunction> function = Handle<JSFunction>::cast(function_object);
SharedFunctionInfo sfi = function->shared();
if (sfi.abstract_code().kind() != AbstractCode::INTERPRETED_FUNCTION &&
sfi.abstract_code().kind() != AbstractCode::BUILTIN) {
if (sfi.abstract_code().kind() != CodeKind::INTERPRETED_FUNCTION &&
sfi.abstract_code().kind() != CodeKind::BUILTIN) {
return CrashUnlessFuzzing(isolate);
}
sfi.DisableOptimization(BailoutReason::kNeverOptimize);
@ -1157,7 +1157,7 @@ RUNTIME_FUNCTION(Runtime_IsWasmCode) {
SealHandleScope shs(isolate);
DCHECK_EQ(1, args.length());
CONVERT_ARG_CHECKED(JSFunction, function, 0);
bool is_js_to_wasm = function.code().kind() == Code::JS_TO_WASM_FUNCTION;
bool is_js_to_wasm = function.code().kind() == CodeKind::JS_TO_WASM_FUNCTION;
return isolate->heap()->ToBoolean(is_js_to_wasm);
}

2
src/snapshot/serializer.cc
View File

@ -165,7 +165,7 @@ bool Serializer::SerializeBackReference(HeapObject obj) {
bool Serializer::ObjectIsBytecodeHandler(HeapObject obj) const {
if (!obj.IsCode()) return false;
return (Code::cast(obj).kind() == Code::BYTECODE_HANDLER);
return (Code::cast(obj).kind() == CodeKind::BYTECODE_HANDLER);
}
void Serializer::PutRoot(RootIndex root, HeapObject object) {

4
src/snapshot/startup-serializer.cc
View File

@ -86,11 +86,11 @@ bool IsUnexpectedCodeObject(Isolate* isolate, HeapObject obj) {
Code code = Code::cast(obj);
// TODO(v8:8768): Deopt entry code should not be serialized.
if (code.kind() == Code::STUB && isolate->deoptimizer_data() != nullptr) {
if (code.kind() == CodeKind::STUB && isolate->deoptimizer_data() != nullptr) {
if (isolate->deoptimizer_data()->IsDeoptEntryCode(code)) return false;
}
if (code.kind() == Code::REGEXP) return false;
if (code.kind() == CodeKind::REGEXP) return false;
if (!code.is_builtin()) return true;
if (code.is_off_heap_trampoline()) return false;

6
src/wasm/wasm-objects.cc
View File

@ -1748,7 +1748,7 @@ uint32_t WasmExceptionPackage::GetEncodedSize(
bool WasmExportedFunction::IsWasmExportedFunction(Object object) {
if (!object.IsJSFunction()) return false;
JSFunction js_function = JSFunction::cast(object);
if (Code::JS_TO_WASM_FUNCTION != js_function.code().kind() &&
if (CodeKind::JS_TO_WASM_FUNCTION != js_function.code().kind() &&
js_function.code().builtin_index() != Builtins::kGenericJSToWasmWrapper) {
return false;
}
@ -1761,7 +1761,7 @@ bool WasmCapiFunction::IsWasmCapiFunction(Object object) {
JSFunction js_function = JSFunction::cast(object);
// TODO(jkummerow): Enable this when there is a JavaScript wrapper
// able to call this function.
// if (js_function->code()->kind() != Code::WASM_TO_CAPI_FUNCTION) {
// if (js_function->code()->kind() != CodeKind::WASM_TO_CAPI_FUNCTION) {
// return false;
// }
// DCHECK(js_function->shared()->HasWasmCapiFunctionData());
@ -1801,7 +1801,7 @@ Handle<WasmExportedFunction> WasmExportedFunction::New(
Isolate* isolate, Handle<WasmInstanceObject> instance, int func_index,
int arity, Handle<Code> export_wrapper) {
DCHECK(
Code::JS_TO_WASM_FUNCTION == export_wrapper->kind() ||
CodeKind::JS_TO_WASM_FUNCTION == export_wrapper->kind() ||
(export_wrapper->is_builtin() &&
export_wrapper->builtin_index() == Builtins::kGenericJSToWasmWrapper));
int num_imported_functions = instance->module()->num_imported_functions;

3
test/cctest/assembler-helper-arm.cc
View File

@ -21,7 +21,8 @@ Handle<Code> AssembleCodeImpl(std::function<void(MacroAssembler&)> assemble) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
if (FLAG_print_code) {
code->Print();
}

4
test/cctest/cctest.cc
View File

@ -245,8 +245,6 @@ HandleAndZoneScope::HandleAndZoneScope(bool support_zone_compression)
HandleAndZoneScope::~HandleAndZoneScope() = default;
static constexpr bool kNativeContextDependent = false;
i::Handle<i::JSFunction> Optimize(
i::Handle<i::JSFunction> function, i::Zone* zone, i::Isolate* isolate,
uint32_t flags, std::unique_ptr<i::compiler::JSHeapBroker>* out_broker) {
@ -259,7 +257,7 @@ i::Handle<i::JSFunction> Optimize(
CHECK_NOT_NULL(zone);
i::OptimizedCompilationInfo info(zone, isolate, shared, function,
kNativeContextDependent);
i::CodeKind::OPTIMIZED_FUNCTION);
if (flags & i::OptimizedCompilationInfo::kInlining) {
info.set_inlining();

8
test/cctest/compiler/code-assembler-tester.h
View File

@ -22,19 +22,19 @@ class CodeAssemblerTester {
explicit CodeAssemblerTester(Isolate* isolate, const char* name = "test")
: zone_(isolate->allocator(), ZONE_NAME, kCompressGraphZone),
scope_(isolate),
state_(isolate, &zone_, VoidDescriptor{}, Code::STUB, name,
state_(isolate, &zone_, VoidDescriptor{}, CodeKind::STUB, name,
PoisoningMitigationLevel::kDontPoison) {}
// Test generating code for a JS function (e.g. builtins).
CodeAssemblerTester(Isolate* isolate, int parameter_count,
Code::Kind kind = Code::BUILTIN,
CodeKind kind = CodeKind::BUILTIN,
const char* name = "test")
: zone_(isolate->allocator(), ZONE_NAME, kCompressGraphZone),
scope_(isolate),
state_(isolate, &zone_, parameter_count, kind, name,
PoisoningMitigationLevel::kDontPoison) {}
CodeAssemblerTester(Isolate* isolate, Code::Kind kind,
CodeAssemblerTester(Isolate* isolate, CodeKind kind,
const char* name = "test")
: zone_(isolate->allocator(), ZONE_NAME, kCompressGraphZone),
scope_(isolate),
@ -45,7 +45,7 @@ class CodeAssemblerTester {
const char* name = "test")
: zone_(isolate->allocator(), ZONE_NAME, kCompressGraphZone),
scope_(isolate),
state_(isolate, &zone_, call_descriptor, Code::STUB, name,
state_(isolate, &zone_, call_descriptor, CodeKind::STUB, name,
PoisoningMitigationLevel::kDontPoison, Builtins::kNoBuiltinId) {}
CodeAssemblerState* state() { return &state_; }

4
test/cctest/compiler/codegen-tester.h
View File

@ -40,7 +40,7 @@ class RawMachineAssemblerTester : public HandleAndZoneScope,
InstructionSelector::AlignmentRequirements()) {}
template <typename... ParamMachTypes>
RawMachineAssemblerTester(Code::Kind kind, ParamMachTypes... p)
RawMachineAssemblerTester(CodeKind kind, ParamMachTypes... p)
: HandleAndZoneScope(kCompressGraphZone),
CallHelper<ReturnType>(
main_isolate(),
@ -91,7 +91,7 @@ class RawMachineAssemblerTester : public HandleAndZoneScope,
}
private:
Code::Kind kind_ = Code::Kind::STUB;
CodeKind kind_ = CodeKind::STUB;
MaybeHandle<Code> code_;
};

4
test/cctest/compiler/function-tester.cc
View File

@ -145,15 +145,13 @@ Handle<JSFunction> FunctionTester::Compile(Handle<JSFunction> function) {
return Optimize(function, &zone, isolate, flags_);
}
static constexpr bool kNativeContextDependent = false;
// Compile the given machine graph instead of the source of the function
// and replace the JSFunction's code with the result.
Handle<JSFunction> FunctionTester::CompileGraph(Graph* graph) {
Handle<SharedFunctionInfo> shared(function->shared(), isolate);
Zone zone(isolate->allocator(), ZONE_NAME);
OptimizedCompilationInfo info(&zone, isolate, shared, function,
kNativeContextDependent);
CodeKind::OPTIMIZED_FUNCTION);
auto call_descriptor = Linkage::ComputeIncoming(&zone, &info);
Handle<Code> code =

6
test/cctest/compiler/test-code-generator.cc
View File

@ -77,7 +77,7 @@ Handle<Code> BuildTeardownFunction(Isolate* isolate,
Handle<Code> BuildSetupFunction(Isolate* isolate,
CallDescriptor* call_descriptor,
std::vector<AllocatedOperand> parameters) {
CodeAssemblerTester tester(isolate, 3, Code::BUILTIN,
CodeAssemblerTester tester(isolate, 3, CodeKind::BUILTIN,
"setup"); // Include receiver.
CodeStubAssembler assembler(tester.state());
std::vector<Node*> params;
@ -964,10 +964,10 @@ class CodeGeneratorTester {
explicit CodeGeneratorTester(TestEnvironment* environment,
int extra_stack_space = 0)
: zone_(environment->main_zone()),
info_(ArrayVector("test"), environment->main_zone(), Code::STUB),
info_(ArrayVector("test"), environment->main_zone(), CodeKind::STUB),
linkage_(environment->test_descriptor()),
frame_(environment->test_descriptor()->CalculateFixedFrameSize(
Code::STUB)) {
CodeKind::STUB)) {
// Pick half of the stack parameters at random and move them into spill
// slots, separated by `extra_stack_space` bytes.
// When testing a move with stack slots using CheckAssembleMove or

13
test/cctest/compiler/test-linkage.cc
View File

@ -26,8 +26,6 @@ namespace compiler {
static Operator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
"dummy", 0, 0, 0, 0, 0, 0);
static constexpr bool kNativeContextDependent = false;
// So we can get a real JS function.
static Handle<JSFunction> Compile(const char* source) {
Isolate* isolate = CcTest::i_isolate();
@ -51,7 +49,7 @@ TEST(TestLinkageCreate) {
Handle<JSFunction> function = Compile("a + b");
Handle<SharedFunctionInfo> shared(function->shared(), handles.main_isolate());
OptimizedCompilationInfo info(handles.main_zone(), function->GetIsolate(),
shared, function, kNativeContextDependent);
shared, function, CodeKind::OPTIMIZED_FUNCTION);
auto call_descriptor = Linkage::ComputeIncoming(info.zone(), &info);
CHECK(call_descriptor);
}
@ -69,7 +67,8 @@ TEST(TestLinkageJSFunctionIncoming) {
Handle<SharedFunctionInfo> shared(function->shared(),
handles.main_isolate());
OptimizedCompilationInfo info(handles.main_zone(), function->GetIsolate(),
shared, function, kNativeContextDependent);
shared, function,
CodeKind::OPTIMIZED_FUNCTION);
auto call_descriptor = Linkage::ComputeIncoming(info.zone(), &info);
CHECK(call_descriptor);
@ -86,7 +85,7 @@ TEST(TestLinkageJSCall) {
Handle<JSFunction> function = Compile("a + c");
Handle<SharedFunctionInfo> shared(function->shared(), handles.main_isolate());
OptimizedCompilationInfo info(handles.main_zone(), function->GetIsolate(),
shared, function, kNativeContextDependent);
shared, function, CodeKind::OPTIMIZED_FUNCTION);
for (int i = 0; i < 32; i++) {
auto call_descriptor = Linkage::GetJSCallDescriptor(
@ -110,7 +109,7 @@ TEST(TestLinkageStubCall) {
Isolate* isolate = CcTest::InitIsolateOnce();
Zone zone(isolate->allocator(), ZONE_NAME);
Callable callable = Builtins::CallableFor(isolate, Builtins::kToNumber);
OptimizedCompilationInfo info(ArrayVector("test"), &zone, Code::STUB);
OptimizedCompilationInfo info(ArrayVector("test"), &zone, CodeKind::STUB);
auto call_descriptor = Linkage::GetStubCallDescriptor(
&zone, callable.descriptor(), 0, CallDescriptor::kNoFlags,
Operator::kNoProperties);
@ -130,7 +129,7 @@ TEST(TestFPLinkageStubCall) {
Zone zone(isolate->allocator(), ZONE_NAME);
Callable callable =
Builtins::CallableFor(isolate, Builtins::kWasmFloat64ToNumber);
OptimizedCompilationInfo info(ArrayVector("test"), &zone, Code::STUB);
OptimizedCompilationInfo info(ArrayVector("test"), &zone, CodeKind::STUB);
auto call_descriptor = Linkage::GetStubCallDescriptor(
&zone, callable.descriptor(), 0, CallDescriptor::kNoFlags,
Operator::kNoProperties);

8
test/cctest/compiler/test-multiple-return.cc
View File

@ -163,7 +163,7 @@ void TestReturnMultipleValues(MachineType type) {
m.Return(count, returns.get());
OptimizedCompilationInfo info(ArrayVector("testing"), handles.main_zone(),
Code::WASM_FUNCTION);
CodeKind::WASM_FUNCTION);
Handle<Code> code = Pipeline::GenerateCodeForTesting(
&info, handles.main_isolate(), desc, m.graph(),
AssemblerOptions::Default(handles.main_isolate()),
@ -191,7 +191,7 @@ void TestReturnMultipleValues(MachineType type) {
byte* code_start =
module->AddCodeForTesting(code)->instructions().begin();
RawMachineAssemblerTester<int32_t> mt(Code::Kind::JS_TO_WASM_FUNCTION);
RawMachineAssemblerTester<int32_t> mt(CodeKind::JS_TO_WASM_FUNCTION);
const int input_count = 2 + param_count;
Node* call_inputs[2 + kMaxParamCount];
call_inputs[0] = mt.PointerConstant(code_start);
@ -268,7 +268,7 @@ void ReturnLastValue(MachineType type) {
m.Return(return_count, returns.get());
OptimizedCompilationInfo info(ArrayVector("testing"), handles.main_zone(),
Code::WASM_FUNCTION);
CodeKind::WASM_FUNCTION);
Handle<Code> code = Pipeline::GenerateCodeForTesting(
&info, handles.main_isolate(), desc, m.graph(),
AssemblerOptions::Default(handles.main_isolate()),
@ -331,7 +331,7 @@ void ReturnSumOfReturns(MachineType type) {
m.Return(return_count, returns.get());
OptimizedCompilationInfo info(ArrayVector("testing"), handles.main_zone(),
Code::WASM_FUNCTION);
CodeKind::WASM_FUNCTION);
Handle<Code> code = Pipeline::GenerateCodeForTesting(
&info, handles.main_isolate(), desc, m.graph(),
AssemblerOptions::Default(handles.main_isolate()),

4
test/cctest/compiler/test-run-bytecode-graph-builder.cc
View File

@ -71,8 +71,6 @@ class BytecodeGraphCallable {
Handle<JSFunction> function_;
};
static constexpr bool kNativeContextDependent = false;
class BytecodeGraphTester {
public:
BytecodeGraphTester(Isolate* isolate, const char* script,
@ -125,7 +123,7 @@ class BytecodeGraphTester {
Zone zone(isolate_->allocator(), ZONE_NAME);
Handle<SharedFunctionInfo> shared(function->shared(), isolate_);
OptimizedCompilationInfo compilation_info(&zone, isolate_, shared, function,
kNativeContextDependent);
CodeKind::OPTIMIZED_FUNCTION);
// Compiler relies on canonicalized handles, let's create
// a canonicalized scope and migrate existing handles there.

2
test/cctest/compiler/test-run-native-calls.cc
View File

@ -246,7 +246,7 @@ Handle<Code> CompileGraph(const char* name, CallDescriptor* call_descriptor,
Graph* graph, Schedule* schedule = nullptr) {
Isolate* isolate = CcTest::InitIsolateOnce();
OptimizedCompilationInfo info(ArrayVector("testing"), graph->zone(),
Code::STUB);
CodeKind::STUB);
Handle<Code> code = Pipeline::GenerateCodeForTesting(
&info, isolate, call_descriptor, graph,
AssemblerOptions::Default(isolate), schedule)

16
test/cctest/heap/test-heap.cc
View File

@ -206,7 +206,8 @@ HEAP_TEST(TestNewSpaceRefsInCopiedCode) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
Handle<Code> copy;
{
@ -229,7 +230,8 @@ static void CheckFindCodeObject(Isolate* isolate) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
CHECK(code->IsCode());
HeapObject obj = HeapObject::cast(*code);
@ -240,7 +242,8 @@ static void CheckFindCodeObject(Isolate* isolate) {
CHECK_EQ(*code, found);
}
Handle<Code> copy = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> copy =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
HeapObject obj_copy = HeapObject::cast(*copy);
Object not_right =
isolate->FindCodeObject(obj_copy.address() + obj_copy.Size() / 2);
@ -4442,7 +4445,7 @@ static Handle<Code> DummyOptimizedCode(Isolate* isolate) {
masm.Drop(2);
masm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, Code::OPTIMIZED_FUNCTION)
Factory::CodeBuilder(isolate, desc, CodeKind::OPTIMIZED_FUNCTION)
.set_self_reference(masm.CodeObject())
.Build();
CHECK(code->IsCode());
@ -6464,8 +6467,9 @@ Handle<Code> GenerateDummyImmovableCode(Isolate* isolate) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, Code::STUB).set_immovable().Build();
Handle<Code> code = Factory::CodeBuilder(isolate, desc, CodeKind::STUB)
.set_immovable()
.Build();
CHECK(code->IsCode());
return code;

3
test/cctest/heap/test-weak-references.cc
View File

@ -50,7 +50,8 @@ TEST(WeakReferencesBasic) {
assm.nop(); // supported on all architectures
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
CHECK(code->IsCode());
lh->set_data1(HeapObjectReference::Weak(*code));

4
test/cctest/test-accessor-assembler.cc
View File

@ -107,7 +107,7 @@ TEST(StubCacheSecondaryOffset) {
namespace {
Handle<Code> CreateCodeOfKind(Code::Kind kind) {
Handle<Code> CreateCodeOfKind(CodeKind kind) {
Isolate* isolate(CcTest::InitIsolateOnce());
CodeAssemblerTester data(isolate, kind);
CodeStubAssembler m(data.state());
@ -204,7 +204,7 @@ TEST(TryProbeStubCache) {
// Generate some number of handlers.
for (int i = 0; i < 30; i++) {
handlers.push_back(CreateCodeOfKind(Code::STUB));
handlers.push_back(CreateCodeOfKind(CodeKind::STUB));
}
// Ensure that GC does happen because from now on we are going to fill our

127
test/cctest/test-assembler-arm.cc
View File

@ -60,7 +60,8 @@ TEST(0) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -95,7 +96,8 @@ TEST(1) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -139,7 +141,8 @@ TEST(2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -184,7 +187,8 @@ TEST(3) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -313,7 +317,8 @@ TEST(4) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -374,7 +379,8 @@ TEST(5) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -404,7 +410,8 @@ TEST(6) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -470,7 +477,8 @@ static void TestRoundingMode(VCVTTypes types,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -651,7 +659,8 @@ TEST(8) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -759,7 +768,8 @@ TEST(9) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -863,7 +873,8 @@ TEST(10) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -956,7 +967,8 @@ TEST(11) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -1080,7 +1092,8 @@ TEST(13) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -1151,7 +1164,8 @@ TEST(14) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -2030,7 +2044,8 @@ TEST(15) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -2305,7 +2320,8 @@ TEST(16) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -2382,7 +2398,8 @@ TEST(sdiv) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -2441,7 +2458,8 @@ TEST(udiv) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -2469,7 +2487,8 @@ TEST(smmla) {
__ bx(lr);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2493,7 +2512,8 @@ TEST(smmul) {
__ bx(lr);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2517,7 +2537,8 @@ TEST(sxtb) {
__ bx(lr);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2541,7 +2562,8 @@ TEST(sxtab) {
__ bx(lr);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2565,7 +2587,8 @@ TEST(sxth) {
__ bx(lr);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2589,7 +2612,8 @@ TEST(sxtah) {
__ bx(lr);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2613,7 +2637,8 @@ TEST(uxtb) {
__ bx(lr);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2637,7 +2662,8 @@ TEST(uxtab) {
__ bx(lr);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2661,7 +2687,8 @@ TEST(uxth) {
__ bx(lr);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2685,7 +2712,8 @@ TEST(uxtah) {
__ bx(lr);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2725,7 +2753,8 @@ TEST(rbit) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
@ -2805,7 +2834,7 @@ TEST(code_relative_offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB)
Handle<Code> code = Factory::CodeBuilder(isolate, desc, CodeKind::STUB)
.set_self_reference(code_object)
.Build();
auto f = GeneratedCode<F_iiiii>::FromCode(*code);
@ -2845,7 +2874,8 @@ TEST(msr_mrs) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -2941,7 +2971,8 @@ TEST(ARMv8_float32_vrintX) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -3041,7 +3072,8 @@ TEST(ARMv8_vrintX) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -3177,7 +3209,8 @@ TEST(ARMv8_vsel) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -3267,7 +3300,8 @@ TEST(ARMv8_vminmax_f64) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -3346,7 +3380,8 @@ TEST(ARMv8_vminmax_f32) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -3479,7 +3514,7 @@ static GeneratedCode<F_ppiii> GenerateMacroFloatMinMax(
CodeDesc desc;
assm.GetCode(assm.isolate(), &desc);
Handle<Code> code =
Factory::CodeBuilder(assm.isolate(), desc, Code::STUB).Build();
Factory::CodeBuilder(assm.isolate(), desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -3641,7 +3676,8 @@ TEST(unaligned_loads) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -3683,7 +3719,8 @@ TEST(unaligned_stores) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -3782,7 +3819,8 @@ TEST(vswp) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -3993,7 +4031,8 @@ TEST(split_add_immediate) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -4012,7 +4051,8 @@ TEST(split_add_immediate) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -4034,7 +4074,8 @@ TEST(split_add_immediate) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);

40
test/cctest/test-assembler-arm64.cc
View File

@ -158,16 +158,16 @@ static void InitializeVM() {
#define RUN() simulator.RunFrom(reinterpret_cast<Instruction*>(code->entry()))
#define END() \
__ Debug("End test.", __LINE__, TRACE_DISABLE | LOG_ALL); \
core.Dump(&masm); \
__ PopCalleeSavedRegisters(); \
__ Ret(); \
{ \
CodeDesc desc; \
__ GetCode(masm.isolate(), &desc); \
code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build(); \
if (FLAG_print_code) code->Print(); \
#define END() \
__ Debug("End test.", __LINE__, TRACE_DISABLE | LOG_ALL); \
core.Dump(&masm); \
__ PopCalleeSavedRegisters(); \
__ Ret(); \
{ \
CodeDesc desc; \
__ GetCode(masm.isolate(), &desc); \
code = Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build(); \
if (FLAG_print_code) code->Print(); \
}
#else // ifdef USE_SIMULATOR.
@ -204,15 +204,15 @@ static void InitializeVM() {
f.Call(); \
}
#define END() \
core.Dump(&masm); \
__ PopCalleeSavedRegisters(); \
__ Ret(); \
{ \
CodeDesc desc; \
__ GetCode(masm.isolate(), &desc); \
code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build(); \
if (FLAG_print_code) code->Print(); \
#define END() \
core.Dump(&masm); \
__ PopCalleeSavedRegisters(); \
__ Ret(); \
{ \
CodeDesc desc; \
__ GetCode(masm.isolate(), &desc); \
code = Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build(); \
if (FLAG_print_code) code->Print(); \
}
#endif // ifdef USE_SIMULATOR.
@ -14880,7 +14880,7 @@ TEST(pool_size) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
code = Factory::CodeBuilder(isolate, desc, Code::STUB)
code = Factory::CodeBuilder(isolate, desc, CodeKind::STUB)
.set_self_reference(masm.CodeObject())
.Build();

66
test/cctest/test-assembler-ia32.cc
View File

@ -62,7 +62,8 @@ TEST(AssemblerIa320) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -99,7 +100,8 @@ TEST(AssemblerIa321) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -140,7 +142,8 @@ TEST(AssemblerIa322) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -168,7 +171,8 @@ TEST(AssemblerIa323) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -196,7 +200,8 @@ TEST(AssemblerIa324) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -223,7 +228,8 @@ TEST(AssemblerIa325) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
F0 f = FUNCTION_CAST<F0>(code->entry());
int res = f();
CHECK_EQ(42, res);
@ -255,7 +261,8 @@ TEST(AssemblerIa326) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -286,7 +293,8 @@ TEST(AssemblerIa328) {
__ ret(0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -368,7 +376,8 @@ TEST(AssemblerMultiByteNop) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
CHECK(code->IsCode());
F0 f = FUNCTION_CAST<F0>(code->entry());
@ -418,7 +427,8 @@ void DoSSE2(const v8::FunctionCallbackInfo<v8::Value>& args) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
F0 f = FUNCTION_CAST<F0>(code->entry());
int res = f();
@ -482,7 +492,8 @@ TEST(AssemblerIa32Extractps) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -520,7 +531,8 @@ TEST(AssemblerIa32SSE) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -552,7 +564,8 @@ TEST(AssemblerIa32SSE3) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -779,7 +792,8 @@ TEST(AssemblerX64FMA_sd) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1006,7 +1020,8 @@ TEST(AssemblerX64FMA_ss) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1113,7 +1128,8 @@ TEST(AssemblerIa32BMI1) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1160,7 +1176,8 @@ TEST(AssemblerIa32LZCNT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1207,7 +1224,8 @@ TEST(AssemblerIa32POPCNT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1352,7 +1370,8 @@ TEST(AssemblerIa32BMI2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1395,7 +1414,8 @@ TEST(AssemblerIa32JumpTables1) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1442,7 +1462,8 @@ TEST(AssemblerIa32JumpTables2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1484,7 +1505,8 @@ TEST(Regress621926) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;

248
test/cctest/test-assembler-mips.cc
View File

@ -64,7 +64,8 @@ TEST(MIPS0) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int res = reinterpret_cast<int>(f.Call(0xAB0, 0xC, 0, 0, 0));
CHECK_EQ(static_cast<int32_t>(0xABC), res);
@ -98,7 +99,8 @@ TEST(MIPS1) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F1>::FromCode(*code);
int res = reinterpret_cast<int>(f.Call(50, 0, 0, 0, 0));
CHECK_EQ(1275, res);
@ -234,7 +236,8 @@ TEST(MIPS2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int res = reinterpret_cast<int>(f.Call(0xAB0, 0xC, 0, 0, 0));
CHECK_EQ(static_cast<int32_t>(0x31415926), res);
@ -333,7 +336,8 @@ TEST(MIPS3) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
// Double test values.
t.a = 1.5e14;
@ -434,7 +438,8 @@ TEST(MIPS4) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.a = 1.5e22;
t.b = 2.75e11;
@ -494,7 +499,8 @@ TEST(MIPS5) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.a = 1.5e4;
t.b = 2.75e8;
@ -561,7 +567,8 @@ TEST(MIPS6) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.ui = 0x11223344;
t.si = 0x99AABBCC;
@ -652,7 +659,8 @@ TEST(MIPS7) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.a = 1.5e14;
t.b = 2.75e11;
@ -747,7 +755,8 @@ TEST(MIPS8) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.input = 0x12345678;
f.Call(&t, 0x0, 0, 0, 0);
@ -791,7 +800,8 @@ TEST(MIPS9) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
USE(code);
}
@ -841,7 +851,8 @@ TEST(MIPS10) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.a = 2.147483646e+09; // 0x7FFFFFFE -> 0xFF80000041DFFFFF as double.
t.b_word = 0x0FF00FF0; // 0x0FF00FF0 -> 0x as double.
@ -967,7 +978,8 @@ TEST(MIPS11) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.reg_init = 0xAABBCCDD;
t.mem_init = 0x11223344;
@ -1091,7 +1103,8 @@ TEST(MIPS12) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.x = 1;
t.y = 2;
@ -1143,7 +1156,8 @@ TEST(MIPS13) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.cvt_big_in = 0xFFFFFFFF;
@ -1262,7 +1276,8 @@ TEST(MIPS14) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.round_up_in = 123.51;
@ -1365,7 +1380,8 @@ TEST(seleqz_selnez) {
__ nop();
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
(f.Call(&test, 0, 0, 0, 0));
@ -1478,7 +1494,8 @@ TEST(min_max) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputsa[i];
@ -1587,7 +1604,8 @@ TEST(rint_d) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int j = 0; j < 4; j++) {
@ -1633,7 +1651,8 @@ TEST(sel) {
__ nop();
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
const int test_size = 3;
@ -1764,7 +1783,8 @@ TEST(rint_s) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int j = 0; j < 4; j++) {
@ -1807,7 +1827,8 @@ TEST(Cvt_d_uw) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.input = inputs[i];
@ -1887,7 +1908,8 @@ TEST(mina_maxa) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputsa[i];
@ -1966,7 +1988,8 @@ TEST(trunc_l) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2045,7 +2068,8 @@ TEST(movz_movn) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2146,7 +2170,7 @@ TEST(movt_movd) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
(f.Call(&test, 0, 0, 0, 0));
@ -2230,7 +2254,8 @@ TEST(cvt_w_d) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int j = 0; j < 4; j++) {
test.fcsr = fcsr_inputs[j];
@ -2296,7 +2321,8 @@ TEST(trunc_w) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2364,7 +2390,8 @@ TEST(round_w) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2434,7 +2461,8 @@ TEST(round_l) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2506,7 +2534,8 @@ TEST(sub) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputfs_S[i];
@ -2584,7 +2613,8 @@ TEST(sqrt_rsqrt_recip) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
@ -2663,7 +2693,8 @@ TEST(neg) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_S[i];
@ -2719,7 +2750,8 @@ TEST(mul) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputfs_S[i];
@ -2774,7 +2806,8 @@ TEST(mov) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2840,7 +2873,8 @@ TEST(floor_w) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2910,7 +2944,8 @@ TEST(floor_l) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2981,7 +3016,8 @@ TEST(ceil_w) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -3051,7 +3087,8 @@ TEST(ceil_l) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -3118,7 +3155,8 @@ TEST(jump_tables1) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -3182,7 +3220,8 @@ TEST(jump_tables2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -3253,7 +3292,8 @@ TEST(jump_tables3) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -3303,7 +3343,8 @@ TEST(BITSWAP) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.r1 = 0x781A15C3;
t.r2 = 0x8B71FCDE;
@ -3436,7 +3477,8 @@ TEST(class_fmt) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.dSignalingNan = std::numeric_limits<double>::signaling_NaN();
@ -3526,7 +3568,8 @@ TEST(ABS) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.a = -2.0;
test.b = -2.0;
@ -3618,7 +3661,8 @@ TEST(ADD_FMT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.a = 2.0;
test.b = 3.0;
@ -3771,7 +3815,8 @@ TEST(C_COND_FMT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.dOp1 = 2.0;
test.dOp2 = 3.0;
@ -3970,7 +4015,8 @@ TEST(CMP_COND_FMT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
uint64_t dTrue = 0xFFFFFFFFFFFFFFFF;
uint64_t dFalse = 0x0000000000000000;
@ -4155,7 +4201,8 @@ TEST(CVT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.cvt_d_s_in = -0.51;
@ -4366,7 +4413,8 @@ TEST(DIV_FMT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
@ -4457,7 +4505,8 @@ uint32_t run_align(uint32_t rs_value, uint32_t rt_value, uint8_t bp) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -4511,7 +4560,8 @@ uint32_t run_aluipc(int16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
PC = (uint32_t)code->entry(); // Set the program counter.
@ -4563,7 +4613,8 @@ uint32_t run_auipc(int16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
PC = (uint32_t)code->entry(); // Set the program counter.
@ -4637,7 +4688,8 @@ uint32_t run_lwpc(int offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -4716,7 +4768,8 @@ uint32_t run_jic(int16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -4786,7 +4839,8 @@ uint64_t run_beqzc(int32_t value, int32_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -4891,7 +4945,8 @@ void run_bz_bnz(TestCaseMsaBranch* input, Branch GenerateBranch,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -5060,7 +5115,8 @@ uint32_t run_jialc(int16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5107,7 +5163,8 @@ static uint32_t run_addiupc(int32_t imm19) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
PC = (uint32_t)code->entry(); // Set the program counter.
@ -5188,7 +5245,8 @@ int32_t run_bc(int32_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5268,7 +5326,8 @@ int32_t run_balc(int32_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5291,7 +5350,8 @@ uint32_t run_aui(uint32_t rs, uint16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5379,7 +5439,8 @@ uint32_t run_bal(int16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5430,7 +5491,8 @@ TEST(Trampoline) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int32_t res = reinterpret_cast<int32_t>(f.Call(42, 42, 0, 0, 0));
@ -5556,7 +5618,8 @@ void helper_madd_msub_maddf_msubf(F func) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
const size_t kTableLength = sizeof(test_cases) / sizeof(TestCaseMaddMsub<T>);
@ -5640,7 +5703,8 @@ uint32_t run_Subu(uint32_t imm, int32_t num_instr) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint32_t res = reinterpret_cast<uint32_t>(f.Call(0, 0, 0, 0, 0));
@ -5743,7 +5807,8 @@ TEST(MSA_fill_copy) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -5810,7 +5875,8 @@ TEST(MSA_fill_copy_2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -5866,7 +5932,8 @@ TEST(MSA_fill_copy_3) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -5910,7 +5977,8 @@ void run_msa_insert(int32_t rs_value, int n, msa_reg_t* w) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6009,7 +6077,8 @@ TEST(MSA_move_v) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6053,7 +6122,8 @@ void run_msa_sldi(OperFunc GenerateOperation,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6137,7 +6207,8 @@ void run_msa_ctc_cfc(uint32_t value) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6246,7 +6317,8 @@ void run_msa_i8(SecondaryField opcode, uint64_t ws_lo, uint64_t ws_hi,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6423,7 +6495,8 @@ uint32_t run_Ins(uint32_t imm, uint32_t source, uint16_t pos, uint16_t size) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint32_t res = reinterpret_cast<uint32_t>(f.Call(0, 0, 0, 0, 0));
@ -6472,7 +6545,8 @@ uint32_t run_Ext(uint32_t source, uint16_t pos, uint16_t size) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint32_t res = reinterpret_cast<uint32_t>(f.Call(0, 0, 0, 0, 0));
@ -6533,7 +6607,8 @@ void run_msa_i5(struct TestCaseMsaI5* input, bool i5_sign_ext,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6952,7 +7027,8 @@ void run_msa_2r(const struct TestCaseMsa2R* input,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -8001,7 +8077,8 @@ void run_msa_vector(struct TestCaseMsaVector* input,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -8088,7 +8165,8 @@ void run_msa_bit(struct TestCaseMsaBit* input, InstFunc GenerateInstructionFunc,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -8560,7 +8638,8 @@ void run_msa_i10(int32_t input, InstFunc GenerateVectorInstructionFunc,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -8637,7 +8716,8 @@ void run_msa_mi10(InstFunc GenerateVectorInstructionFunc) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -8715,7 +8795,8 @@ void run_msa_3r(struct TestCaseMsa3R* input, InstFunc GenerateI5InstructionFunc,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -9720,7 +9801,8 @@ void run_msa_3rf(const struct TestCaseMsa3RF* input,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif

278
test/cctest/test-assembler-mips64.cc
View File

@ -65,7 +65,8 @@ TEST(MIPS0) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(0xAB0, 0xC, 0, 0, 0));
CHECK_EQ(0xABCL, res);
@ -99,7 +100,8 @@ TEST(MIPS1) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F1>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(50, 0, 0, 0, 0));
CHECK_EQ(1275L, res);
@ -243,7 +245,8 @@ TEST(MIPS2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(0xAB0, 0xC, 0, 0, 0));
@ -343,7 +346,8 @@ TEST(MIPS3) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
// Double test values.
t.a = 1.5e14;
@ -434,7 +438,8 @@ TEST(MIPS4) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.a = 1.5e22;
t.b = 2.75e11;
@ -497,7 +502,8 @@ TEST(MIPS5) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.a = 1.5e4;
t.b = 2.75e8;
@ -564,7 +570,8 @@ TEST(MIPS6) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.ui = 0x11223344;
t.si = 0x99AABBCC;
@ -649,7 +656,8 @@ TEST(MIPS7) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.a = 1.5e14;
t.b = 2.75e11;
@ -744,7 +752,8 @@ TEST(MIPS8) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.input = 0x12345678;
f.Call(&t, 0x0, 0, 0, 0);
@ -788,7 +797,8 @@ TEST(MIPS9) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
USE(code);
}
@ -863,7 +873,8 @@ TEST(MIPS10) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.a = 2.147483647e9; // 0x7FFFFFFF -> 0x41DFFFFFFFC00000 as double.
t.b_long_hi = 0x000000FF; // 0xFF00FF00FF -> 0x426FE01FE01FE000 as double.
@ -996,7 +1007,8 @@ TEST(MIPS11) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.reg_init = 0xAABBCCDD;
t.mem_init = 0x11223344;
@ -1119,7 +1131,8 @@ TEST(MIPS12) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.x = 1;
t.y = 2;
@ -1171,7 +1184,8 @@ TEST(MIPS13) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.cvt_big_in = 0xFFFFFFFF;
@ -1290,7 +1304,8 @@ TEST(MIPS14) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.round_up_in = 123.51;
@ -1417,7 +1432,8 @@ TEST(MIPS16) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.ui = 0x44332211;
t.si = 0x99AABBCC;
@ -1543,7 +1559,8 @@ TEST(seleqz_selnez) {
__ nop();
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
f.Call(&test, 0, 0, 0, 0);
@ -1657,7 +1674,8 @@ TEST(min_max) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 4; i < kTableLength; i++) {
test.a = inputsa[i];
@ -1764,7 +1782,8 @@ TEST(rint_d) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int j = 0; j < 4; j++) {
@ -1810,7 +1829,8 @@ TEST(sel) {
__ nop();
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
const int test_size = 3;
@ -1941,7 +1961,8 @@ TEST(rint_s) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int j = 0; j < 4; j++) {
@ -2025,7 +2046,8 @@ TEST(mina_maxa) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputsa[i];
@ -2105,7 +2127,8 @@ TEST(trunc_l) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2184,7 +2207,8 @@ TEST(movz_movn) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2284,7 +2308,7 @@ TEST(movt_movd) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
f.Call(&test, 0, 0, 0, 0);
@ -2369,7 +2393,8 @@ TEST(cvt_w_d) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int j = 0; j < 4; j++) {
test.fcsr = fcsr_inputs[j];
@ -2435,7 +2460,8 @@ TEST(trunc_w) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2503,7 +2529,8 @@ TEST(round_w) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2572,7 +2599,8 @@ TEST(round_l) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2643,7 +2671,8 @@ TEST(sub) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputfs_S[i];
@ -2714,7 +2743,8 @@ TEST(sqrt_rsqrt_recip) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
@ -2791,7 +2821,8 @@ TEST(neg) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_S[i];
@ -2848,7 +2879,8 @@ TEST(mul) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputfs_S[i];
@ -2902,7 +2934,8 @@ TEST(mov) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -2968,7 +3001,8 @@ TEST(floor_w) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -3037,7 +3071,8 @@ TEST(floor_l) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -3107,7 +3142,8 @@ TEST(ceil_w) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -3176,7 +3212,8 @@ TEST(ceil_l) {
Test test;
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
@ -3242,7 +3279,8 @@ TEST(jump_tables1) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -3306,7 +3344,8 @@ TEST(jump_tables2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -3380,7 +3419,8 @@ TEST(jump_tables3) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -3452,7 +3492,8 @@ TEST(BITSWAP) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.r1 = 0x00102100781A15C3;
t.r2 = 0x001021008B71FCDE;
@ -3593,7 +3634,8 @@ TEST(class_fmt) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
// Double test values.
@ -3685,7 +3727,8 @@ TEST(ABS) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.a = -2.0;
test.b = -2.0;
@ -3777,7 +3820,8 @@ TEST(ADD_FMT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.a = 2.0;
test.b = 3.0;
@ -3930,7 +3974,8 @@ TEST(C_COND_FMT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.dOp1 = 2.0;
test.dOp2 = 3.0;
@ -4129,7 +4174,8 @@ TEST(CMP_COND_FMT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
uint64_t dTrue = 0xFFFFFFFFFFFFFFFF;
uint64_t dFalse = 0x0000000000000000;
@ -4306,7 +4352,8 @@ TEST(CVT) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.cvt_d_s_in = -0.51;
@ -4476,7 +4523,8 @@ TEST(DIV_FMT) {
__ nop();
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
f.Call(&test, 0, 0, 0, 0);
@ -4566,7 +4614,8 @@ uint64_t run_align(uint64_t rs_value, uint64_t rt_value, uint8_t bp) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F4>::FromCode(*code);
@ -4620,7 +4669,8 @@ uint64_t run_dalign(uint64_t rs_value, uint64_t rt_value, uint8_t bp) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F4>::FromCode(*code);
uint64_t res =
@ -4679,7 +4729,8 @@ uint64_t run_aluipc(int16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
PC = (uint64_t)code->entry(); // Set the program counter.
@ -4731,7 +4782,8 @@ uint64_t run_auipc(int16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
PC = (uint64_t)code->entry(); // Set the program counter.
@ -4784,7 +4836,8 @@ uint64_t run_aui(uint64_t rs, uint16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -4807,7 +4860,8 @@ uint64_t run_daui(uint64_t rs, uint16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -4830,7 +4884,8 @@ uint64_t run_dahi(uint64_t rs, uint16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -4853,7 +4908,8 @@ uint64_t run_dati(uint64_t rs, uint16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -4955,7 +5011,8 @@ uint64_t run_li_macro(uint64_t imm, LiFlags mode, int32_t num_instr = 0) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -5166,7 +5223,8 @@ uint64_t run_lwpc(int offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5242,7 +5300,8 @@ uint64_t run_lwupc(int offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5321,7 +5380,8 @@ uint64_t run_jic(int16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5391,7 +5451,8 @@ uint64_t run_beqzc(int32_t value, int32_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5496,7 +5557,8 @@ void run_bz_bnz(TestCaseMsaBranch* input, Branch GenerateBranch,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -5665,7 +5727,8 @@ uint64_t run_jialc(int16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5715,7 +5778,8 @@ uint64_t run_addiupc(int32_t imm19) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
PC = (uint64_t)code->entry(); // Set the program counter.
@ -5789,7 +5853,8 @@ uint64_t run_ldpc(int offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5876,7 +5941,8 @@ int64_t run_bc(int32_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -5956,7 +6022,8 @@ int64_t run_balc(int32_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -6004,7 +6071,8 @@ uint64_t run_dsll(uint64_t rt_value, uint16_t sa_value) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F4>::FromCode(*code);
@ -6060,7 +6128,8 @@ uint64_t run_bal(int16_t offset) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
@ -6113,7 +6182,8 @@ TEST(Trampoline) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(42, 42, 0, 0, 0));
@ -6239,7 +6309,8 @@ void helper_madd_msub_maddf_msubf(F func) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
const size_t kTableLength = sizeof(test_cases) / sizeof(TestCaseMaddMsub<T>);
@ -6321,7 +6392,8 @@ uint64_t run_Subu(uint64_t imm, int32_t num_instr) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6403,7 +6475,8 @@ uint64_t run_Dsubu(uint64_t imm, int32_t num_instr) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6498,7 +6571,8 @@ uint64_t run_Dins(uint64_t imm, uint64_t source, uint16_t pos, uint16_t size) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(0, 0, 0, 0, 0));
@ -6557,7 +6631,8 @@ uint64_t run_Ins(uint64_t imm, uint64_t source, uint16_t pos, uint16_t size) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(0, 0, 0, 0, 0));
@ -6624,7 +6699,8 @@ uint64_t run_Ext(uint64_t source, uint16_t pos, uint16_t size) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(0, 0, 0, 0, 0));
@ -6706,7 +6782,8 @@ TEST(MSA_fill_copy) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6768,7 +6845,8 @@ TEST(MSA_fill_copy_2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6820,7 +6898,8 @@ TEST(MSA_fill_copy_3) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6868,7 +6947,8 @@ void run_msa_insert(int64_t rs_value, int n, msa_reg_t* w) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -6977,7 +7057,8 @@ void run_msa_ctc_cfc(uint64_t value) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -7025,7 +7106,8 @@ TEST(MSA_move_v) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -7069,7 +7151,8 @@ void run_msa_sldi(OperFunc GenerateOperation,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -7228,7 +7311,8 @@ void run_msa_i8(SecondaryField opcode, uint64_t ws_lo, uint64_t ws_hi,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -7431,7 +7515,8 @@ void run_msa_i5(struct TestCaseMsaI5* input, bool i5_sign_ext,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -7856,7 +7941,8 @@ void run_msa_2r(const struct TestCaseMsa2R* input,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -8905,7 +8991,8 @@ void run_msa_vector(struct TestCaseMsaVector* input,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -8992,7 +9079,8 @@ void run_msa_bit(struct TestCaseMsaBit* input, InstFunc GenerateInstructionFunc,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -9464,7 +9552,8 @@ void run_msa_i10(int32_t input, InstFunc GenerateVectorInstructionFunc,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -9541,7 +9630,8 @@ void run_msa_mi10(InstFunc GenerateVectorInstructionFunc) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -9619,7 +9709,8 @@ void run_msa_3r(struct TestCaseMsa3R* input, InstFunc GenerateI5InstructionFunc,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -10623,7 +10714,8 @@ void run_msa_3rf(const struct TestCaseMsa3RF* input,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif

28
test/cctest/test-assembler-ppc.cc
View File

@ -60,7 +60,8 @@ TEST(0) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -95,7 +96,8 @@ TEST(1) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -142,7 +144,8 @@ TEST(2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -210,7 +213,8 @@ TEST(3) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -323,7 +327,7 @@ TEST(4) {
assm.GetCode(isolate, &desc);
Object code = isolate->heap()->CreateCode(
desc,
Code::STUB,
CodeKind::STUB,
Handle<Code>())->ToObjectChecked();
CHECK(code->IsCode());
#ifdef DEBUG
@ -383,7 +387,7 @@ TEST(5) {
assm.GetCode(isolate, &desc);
Object code = isolate->heap()->CreateCode(
desc,
Code::STUB,
CodeKind::STUB,
Handle<Code>())->ToObjectChecked();
CHECK(code->IsCode());
#ifdef DEBUG
@ -418,7 +422,7 @@ TEST(6) {
assm.GetCode(isolate, &desc);
Object code = isolate->heap()->CreateCode(
desc,
Code::STUB,
CodeKind::STUB,
Handle<Code>())->ToObjectChecked();
CHECK(code->IsCode());
#ifdef DEBUG
@ -493,7 +497,7 @@ static void TestRoundingMode(VCVTTypes types,
assm.GetCode(isolate, &desc);
Object code = isolate->heap()->CreateCode(
desc,
Code::STUB,
CodeKind::STUB,
Handle<Code>())->ToObjectChecked();
CHECK(code->IsCode());
#ifdef DEBUG
@ -680,7 +684,7 @@ TEST(8) {
assm.GetCode(isolate, &desc);
Object code = isolate->heap()->CreateCode(
desc,
Code::STUB,
CodeKind::STUB,
Handle<Code>())->ToObjectChecked();
CHECK(code->IsCode());
#ifdef DEBUG
@ -795,7 +799,7 @@ TEST(9) {
assm.GetCode(isolate, &desc);
Object code = isolate->heap()->CreateCode(
desc,
Code::STUB,
CodeKind::STUB,
Handle<Code>())->ToObjectChecked();
CHECK(code->IsCode());
#ifdef DEBUG
@ -906,7 +910,7 @@ TEST(10) {
assm.GetCode(isolate, &desc);
Object code = isolate->heap()->CreateCode(
desc,
Code::STUB,
CodeKind::STUB,
Handle<Code>())->ToObjectChecked();
CHECK(code->IsCode());
#ifdef DEBUG
@ -1003,7 +1007,7 @@ TEST(11) {
assm.GetCode(isolate, &desc);
Object code = isolate->heap()->CreateCode(
desc,
Code::STUB,
CodeKind::STUB,
Handle<Code>())->ToObjectChecked();
CHECK(code->IsCode());
#ifdef DEBUG

51
test/cctest/test-assembler-s390.cc
View File

@ -63,7 +63,8 @@ TEST(0) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -101,7 +102,8 @@ TEST(1) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -151,7 +153,8 @@ TEST(2) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -205,7 +208,8 @@ TEST(3) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -246,7 +250,7 @@ TEST(4) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = isolate->factory()->NewCode(
desc, Code::STUB, Handle<Code>());
desc, CodeKind::STUB, Handle<Code>());
#ifdef DEBUG
code->Print();
#endif
@ -274,7 +278,7 @@ TEST(5) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = isolate->factory()->NewCode(
desc, Code::STUB, Handle<Code>());
desc, CodeKind::STUB, Handle<Code>());
#ifdef DEBUG
code->Print();
#endif
@ -308,7 +312,7 @@ TEST(6) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = isolate->factory()->NewCode(
desc, Code::STUB, Handle<Code>());
desc, CodeKind::STUB, Handle<Code>());
#ifdef DEBUG
code->Print();
#endif
@ -340,7 +344,7 @@ TEST(7) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = isolate->factory()->NewCode(
desc, Code::STUB, Handle<Code>());
desc, CodeKind::STUB, Handle<Code>());
#ifdef DEBUG
code->Print();
#endif
@ -371,7 +375,7 @@ TEST(8) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = isolate->factory()->NewCode(
desc, Code::STUB, Handle<Code>());
desc, CodeKind::STUB, Handle<Code>());
#ifdef DEBUG
code->Print();
#endif
@ -398,7 +402,7 @@ TEST(9) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = isolate->factory()->NewCode(
desc, Code::STUB, Handle<Code>());
desc, CodeKind::STUB, Handle<Code>());
#ifdef DEBUG
code->Print();
#endif
@ -482,7 +486,8 @@ TEST(10) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -535,7 +540,8 @@ TEST(11) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -588,7 +594,8 @@ TEST(12) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -651,7 +658,8 @@ TEST(13) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -741,7 +749,8 @@ TEST(14) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -830,7 +839,8 @@ TEST(15) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -876,7 +886,8 @@ TEST(16) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -949,7 +960,8 @@ TEST(17) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif
@ -1040,7 +1052,8 @@ TEST(18) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
code->Print();
#endif

51
test/cctest/test-assembler-x64.cc
View File

@ -743,7 +743,8 @@ TEST(AssemblerMultiByteNop) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F0>::FromCode(*code);
int res = f.Call();
@ -799,7 +800,8 @@ void DoSSE2(const v8::FunctionCallbackInfo<v8::Value>& args) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F0>::FromCode(*code);
int res = f.Call();
@ -863,7 +865,8 @@ TEST(AssemblerX64Extractps) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -899,7 +902,8 @@ TEST(AssemblerX64SSE) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -929,7 +933,8 @@ TEST(AssemblerX64SSE3) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1153,7 +1158,8 @@ TEST(AssemblerX64FMA_sd) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1378,7 +1384,8 @@ TEST(AssemblerX64FMA_ss) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1453,7 +1460,8 @@ TEST(AssemblerX64SSE_ss) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1538,7 +1546,8 @@ TEST(AssemblerX64AVX_ss) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1777,7 +1786,8 @@ TEST(AssemblerX64AVX_sd) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -1968,7 +1978,8 @@ TEST(AssemblerX64BMI1) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -2027,7 +2038,8 @@ TEST(AssemblerX64LZCNT) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -2086,7 +2098,8 @@ TEST(AssemblerX64POPCNT) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -2348,7 +2361,8 @@ TEST(AssemblerX64BMI2) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);
@ -2391,7 +2405,8 @@ TEST(AssemblerX64JumpTables1) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2438,7 +2453,8 @@ TEST(AssemblerX64JumpTables2) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -2494,7 +2510,8 @@ TEST(AssemblerX64vmovups) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);

6
test/cctest/test-code-layout.cc
View File

@ -40,7 +40,8 @@ TEST(CodeLayoutWithoutUnwindingInfo) {
code_desc.origin = nullptr;
Handle<Code> code =
Factory::CodeBuilder(CcTest::i_isolate(), code_desc, Code::STUB).Build();
Factory::CodeBuilder(CcTest::i_isolate(), code_desc, CodeKind::STUB)
.Build();
CHECK(!code->has_unwinding_info());
CHECK_EQ(code->raw_instruction_size(), buffer_size);
@ -86,7 +87,8 @@ TEST(CodeLayoutWithUnwindingInfo) {
code_desc.origin = nullptr;
Handle<Code> code =
Factory::CodeBuilder(CcTest::i_isolate(), code_desc, Code::STUB).Build();
Factory::CodeBuilder(CcTest::i_isolate(), code_desc, CodeKind::STUB)
.Build();
CHECK(code->has_unwinding_info());
CHECK_EQ(code->raw_instruction_size(), buffer_size);

14
test/cctest/test-code-pages.cc
View File

@ -282,7 +282,7 @@ TEST(LargeCodeObject) {
{
HandleScope scope(i_isolate);
Handle<Code> foo_code =
Factory::CodeBuilder(i_isolate, desc, Code::WASM_FUNCTION).Build();
Factory::CodeBuilder(i_isolate, desc, CodeKind::WASM_FUNCTION).Build();
CHECK(i_isolate->heap()->InSpace(*foo_code, CODE_LO_SPACE));
@ -407,7 +407,7 @@ TEST(LargeCodeObjectWithSignalHandler) {
{
HandleScope scope(i_isolate);
Handle<Code> foo_code =
Factory::CodeBuilder(i_isolate, desc, Code::WASM_FUNCTION).Build();
Factory::CodeBuilder(i_isolate, desc, CodeKind::WASM_FUNCTION).Build();
CHECK(i_isolate->heap()->InSpace(*foo_code, CODE_LO_SPACE));
@ -482,7 +482,8 @@ TEST(Sorted) {
Handle<Code> code1, code3;
Address code2_address;
code1 = Factory::CodeBuilder(i_isolate, desc, Code::WASM_FUNCTION).Build();
code1 =
Factory::CodeBuilder(i_isolate, desc, CodeKind::WASM_FUNCTION).Build();
CHECK(i_isolate->heap()->InSpace(*code1, CODE_LO_SPACE));
{
@ -491,10 +492,11 @@ TEST(Sorted) {
// Create three large code objects, we'll delete the middle one and check
// everything is still sorted.
Handle<Code> code2 =
Factory::CodeBuilder(i_isolate, desc, Code::WASM_FUNCTION).Build();
Factory::CodeBuilder(i_isolate, desc, CodeKind::WASM_FUNCTION)
.Build();
CHECK(i_isolate->heap()->InSpace(*code2, CODE_LO_SPACE));
code3 =
Factory::CodeBuilder(i_isolate, desc, Code::WASM_FUNCTION).Build();
code3 = Factory::CodeBuilder(i_isolate, desc, CodeKind::WASM_FUNCTION)
.Build();
CHECK(i_isolate->heap()->InSpace(*code3, CODE_LO_SPACE));
code2_address = code2->address();

2
test/cctest/test-debug.cc
View File

@ -4398,7 +4398,7 @@ TEST(BuiltinsExceptionPrediction) {
bool fail = false;
for (int i = 0; i < i::Builtins::builtin_count; i++) {
i::Code builtin = builtins->builtin(i);
if (builtin.kind() != i::Code::BUILTIN) continue;
if (builtin.kind() != i::CodeKind::BUILTIN) continue;
auto prediction = builtin.GetBuiltinCatchPrediction();
USE(prediction);
}

3
test/cctest/test-disasm-ia32.cc
View File

@ -984,7 +984,8 @@ TEST(DisasmIa320) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
USE(code);
#ifdef OBJECT_PRINT
StdoutStream os;

3
test/cctest/test-disasm-x64.cc
View File

@ -982,7 +982,8 @@ TEST(DisasmX64) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
USE(code);
#ifdef OBJECT_PRINT
StdoutStream os;

11
test/cctest/test-factory.cc
View File

@ -73,7 +73,7 @@ TEST(Factory_CodeBuilder) {
desc.unwinding_info_size = 0;
desc.origin = nullptr;
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, Code::WASM_FUNCTION).Build();
Factory::CodeBuilder(isolate, desc, CodeKind::WASM_FUNCTION).Build();
CHECK(isolate->heap()->InSpace(*code, CODE_LO_SPACE));
#if VERIFY_HEAP
@ -89,9 +89,9 @@ UNINITIALIZED_TEST(Factory_CodeBuilder_BuildOOM) {
desc.instr_size = kInstructionSize;
desc.buffer = instructions.get();
const Handle<Code> code =
Factory::CodeBuilder(isolate_scope.isolate(), desc, Code::WASM_FUNCTION)
.Build();
const Handle<Code> code = Factory::CodeBuilder(isolate_scope.isolate(), desc,
CodeKind::WASM_FUNCTION)
.Build();
CHECK(!code.is_null());
CHECK(isolate_scope.oom_triggered());
@ -106,7 +106,8 @@ UNINITIALIZED_TEST(Factory_CodeBuilder_TryBuildOOM) {
desc.buffer = instructions.get();
const MaybeHandle<Code> code =
Factory::CodeBuilder(isolate_scope.isolate(), desc, Code::WASM_FUNCTION)
Factory::CodeBuilder(isolate_scope.isolate(), desc,
CodeKind::WASM_FUNCTION)
.TryBuild();
CHECK(code.is_null());

2
test/cctest/test-field-type-tracking.cc
View File

@ -585,7 +585,7 @@ Handle<Code> CreateDummyOptimizedCode(Isolate* isolate) {
desc.buffer = buffer;
desc.buffer_size = arraysize(buffer);
desc.instr_size = arraysize(buffer);
return Factory::CodeBuilder(isolate, desc, Code::OPTIMIZED_FUNCTION)
return Factory::CodeBuilder(isolate, desc, CodeKind::OPTIMIZED_FUNCTION)
.set_is_turbofanned()
.Build();
}

2
test/cctest/test-heap-profiler.cc
View File

@ -4075,7 +4075,7 @@ TEST(WeakReference) {
i::CodeDesc desc;
assm.GetCode(i_isolate, &desc);
i::Handle<i::Code> code =
i::Factory::CodeBuilder(i_isolate, desc, i::Code::STUB).Build();
i::Factory::CodeBuilder(i_isolate, desc, i::CodeKind::STUB).Build();
CHECK(code->IsCode());
fv->set_optimized_code_weak_or_smi(i::HeapObjectReference::Weak(*code));

6
test/cctest/test-macro-assembler-arm.cc
View File

@ -146,7 +146,8 @@ TEST(ExtractLane) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -276,7 +277,8 @@ TEST(ReplaceLane) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);

3
test/cctest/test-macro-assembler-arm64.cc
View File

@ -65,7 +65,8 @@ TEST(EmbeddedObj) {
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);

33
test/cctest/test-macro-assembler-mips.cc
View File

@ -88,7 +88,8 @@ TEST(BYTESWAP) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (size_t i = 0; i < arraysize(test_values); i++) {
@ -197,7 +198,8 @@ TEST(jump_tables4) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -259,7 +261,8 @@ TEST(jump_tables5) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -346,7 +349,8 @@ TEST(jump_tables6) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -370,7 +374,8 @@ static uint32_t run_lsa(uint32_t rt, uint32_t rs, int8_t sa) {
CodeDesc desc;
assembler.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F1>::FromCode(*code);
@ -497,7 +502,8 @@ RET_TYPE run_Cvt(IN_TYPE x, Func GenerateConvertInstructionFunc) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F_CVT>::FromCode(*code);
@ -609,7 +615,7 @@ TEST(OverflowInstructions) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.lhs = ii;
t.rhs = jj;
@ -731,7 +737,8 @@ TEST(min_max_nan) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputsa[i];
@ -765,7 +772,8 @@ bool run_Unaligned(char* memory_buffer, int32_t in_offset, int32_t out_offset,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F_CVT>::FromCode(*code);
@ -1011,7 +1019,8 @@ bool run_Sltu(uint32_t rs, uint32_t rd, Func GenerateSltuInstructionFunc) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F_CVT>::FromCode(*code);
int32_t res = reinterpret_cast<int32_t>(f.Call(rs, rd, 0, 0, 0));
@ -1105,7 +1114,7 @@ static GeneratedCode<F4> GenerateMacroFloat32MinMax(MacroAssembler* masm) {
CodeDesc desc;
masm->GetCode(masm->isolate(), &desc);
Handle<Code> code =
Factory::CodeBuilder(masm->isolate(), desc, Code::STUB).Build();
Factory::CodeBuilder(masm->isolate(), desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -1246,7 +1255,7 @@ static GeneratedCode<F4> GenerateMacroFloat64MinMax(MacroAssembler* masm) {
CodeDesc desc;
masm->GetCode(masm->isolate(), &desc);
Handle<Code> code =
Factory::CodeBuilder(masm->isolate(), desc, Code::STUB).Build();
Factory::CodeBuilder(masm->isolate(), desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);

42
test/cctest/test-macro-assembler-mips64.cc
View File

@ -108,7 +108,8 @@ TEST(BYTESWAP) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (size_t i = 0; i < arraysize(test_values); i++) {
@ -162,7 +163,8 @@ TEST(LoadConstants) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<FV>::FromCode(*code);
(void)f.Call(reinterpret_cast<int64_t>(result), 0, 0, 0, 0);
@ -204,7 +206,8 @@ TEST(LoadAddress) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<FV>::FromCode(*code);
(void)f.Call(0, 0, 0, 0, 0);
@ -260,7 +263,8 @@ TEST(jump_tables4) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -329,7 +333,8 @@ TEST(jump_tables5) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -417,7 +422,8 @@ TEST(jump_tables6) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
@ -441,7 +447,8 @@ static uint64_t run_lsa(uint32_t rt, uint32_t rs, int8_t sa) {
CodeDesc desc;
assembler.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F1>::FromCode(*code);
@ -520,7 +527,8 @@ static uint64_t run_dlsa(uint64_t rt, uint64_t rs, int8_t sa) {
CodeDesc desc;
assembler.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<FV>::FromCode(*code);
@ -669,7 +677,8 @@ RET_TYPE run_Cvt(IN_TYPE x, Func GenerateConvertInstructionFunc) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F_CVT>::FromCode(*code);
@ -844,7 +853,7 @@ TEST(OverflowInstructions) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.lhs = ii;
t.rhs = jj;
@ -966,7 +975,8 @@ TEST(min_max_nan) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputsa[i];
@ -1000,7 +1010,8 @@ bool run_Unaligned(char* memory_buffer, int32_t in_offset, int32_t out_offset,
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F_CVT>::FromCode(*code);
@ -1363,7 +1374,8 @@ bool run_Sltu(uint64_t rs, uint64_t rd, Func GenerateSltuInstructionFunc) {
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
auto f = GeneratedCode<F_CVT>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(rs, rd, 0, 0, 0));
@ -1457,7 +1469,7 @@ static GeneratedCode<F4> GenerateMacroFloat32MinMax(MacroAssembler* masm) {
CodeDesc desc;
masm->GetCode(masm->isolate(), &desc);
Handle<Code> code =
Factory::CodeBuilder(masm->isolate(), desc, Code::STUB).Build();
Factory::CodeBuilder(masm->isolate(), desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);
@ -1598,7 +1610,7 @@ static GeneratedCode<F4> GenerateMacroFloat64MinMax(MacroAssembler* masm) {
CodeDesc desc;
masm->GetCode(masm->isolate(), &desc);
Handle<Code> code =
Factory::CodeBuilder(masm->isolate(), desc, Code::STUB).Build();
Factory::CodeBuilder(masm->isolate(), desc, CodeKind::STUB).Build();
#ifdef DEBUG
StdoutStream os;
code->Print(os);

3
test/cctest/test-macro-assembler-x64.cc
View File

@ -449,7 +449,8 @@ TEST(EmbeddedObj) {
CodeDesc desc;
masm->GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
#ifdef OBJECT_PRINT
StdoutStream os;
code->Print(os);

2
test/cctest/test-regexp.cc
View File

@ -2359,7 +2359,7 @@ TEST(UnicodePropertyEscapeCodeSize) {
} else if (maybe_code.IsCode()) {
// On x64, excessive inlining produced >360KB.
CHECK_LT(Code::cast(maybe_code).Size(), kMaxSize);
CHECK_EQ(Code::cast(maybe_code).kind(), Code::REGEXP);
CHECK_EQ(Code::cast(maybe_code).kind(), CodeKind::REGEXP);
} else {
UNREACHABLE();
}

2
test/cctest/test-serialize.cc
View File

@ -1532,7 +1532,7 @@ int CountBuiltins() {
int counter = 0;
for (HeapObject obj = iterator.Next(); !obj.is_null();
obj = iterator.Next()) {
if (obj.IsCode() && Code::cast(obj).kind() == Code::BUILTIN) counter++;
if (obj.IsCode() && Code::cast(obj).kind() == CodeKind::BUILTIN) counter++;
}
return counter;
}

6
test/cctest/test-sync-primitives-arm64.cc
View File

@ -204,7 +204,8 @@ void TestInvalidateExclusiveAccess(TestData initial_data, MemoryAccess access1,
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
TestData t = initial_data;
Simulator::current(isolate)->Call<void>(code->entry(), &t);
@ -275,7 +276,8 @@ int ExecuteMemoryAccess(Isolate* isolate, TestData* test_data,
CodeDesc desc;
masm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc, Code::STUB).Build();
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::STUB).Build();
Simulator::current(isolate)->Call<void>(code->entry(), test_data);
return Simulator::current(isolate)->wreg(0);
}

2
test/cctest/test-unwinder-code-pages.cc
View File

@ -577,7 +577,7 @@ TEST(PCIsInV8_LargeCodeObject_CodePagesAPI) {
desc.unwinding_info_size = 0;
desc.origin = nullptr;
Handle<Code> foo_code =
Factory::CodeBuilder(i_isolate, desc, Code::WASM_FUNCTION).Build();
Factory::CodeBuilder(i_isolate, desc, CodeKind::WASM_FUNCTION).Build();
CHECK(i_isolate->heap()->InSpace(*foo_code, CODE_LO_SPACE));
byte* start = reinterpret_cast<byte*>(foo_code->InstructionStart());

2
test/cctest/test-unwinder.cc
View File

@ -546,7 +546,7 @@ TEST(PCIsInV8_LargeCodeObject) {
desc.unwinding_info_size = 0;
desc.origin = nullptr;
Handle<Code> foo_code =
Factory::CodeBuilder(i_isolate, desc, Code::WASM_FUNCTION).Build();
Factory::CodeBuilder(i_isolate, desc, CodeKind::WASM_FUNCTION).Build();
CHECK(i_isolate->heap()->InSpace(*foo_code, CODE_LO_SPACE));
byte* start = reinterpret_cast<byte*>(foo_code->InstructionStart());

2
test/cctest/wasm/wasm-run-utils.cc
View File

@ -483,7 +483,7 @@ Handle<Code> WasmFunctionWrapper::GetWrapperCode() {
}
OptimizedCompilationInfo info(ArrayVector("testing"), graph()->zone(),
Code::C_WASM_ENTRY);
CodeKind::C_WASM_ENTRY);
code_ = compiler::Pipeline::GenerateCodeForTesting(
&info, isolate, call_descriptor, graph(),
AssemblerOptions::Default(isolate));

4
test/fuzzer/multi-return.cc
View File

@ -239,7 +239,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
}
callee.Return(static_cast<int>(desc->ReturnCount()), returns.get());
OptimizedCompilationInfo info(ArrayVector("testing"), &zone, Code::STUB);
OptimizedCompilationInfo info(ArrayVector("testing"), &zone, CodeKind::STUB);
Handle<Code> code =
Pipeline::GenerateCodeForTesting(&info, i_isolate, desc, callee.graph(),
AssemblerOptions::Default(i_isolate),
@ -285,7 +285,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
// Call the wrapper.
OptimizedCompilationInfo wrapper_info(ArrayVector("wrapper"), &zone,
Code::STUB);
CodeKind::STUB);
Handle<Code> wrapper_code =
Pipeline::GenerateCodeForTesting(
&wrapper_info, i_isolate, wrapper_desc, caller.graph(),

Some files were not shown because too many files have changed in this diff Show More