Merge V8 5.2.361.47 DO NOT MERGE
https://chromium.googlesource.com/v8/v8/+/5.2.361.47
FPIIM-449
Change-Id: Ibec421b85a9b88cb3a432ada642e469fe7e78346
(cherry picked from commit bcf72ee8e3b26f1d0726869c7ddb3921c68b09a8)
diff --git a/test/cctest/cctest.gyp b/test/cctest/cctest.gyp
index 2e00e88..e33ee81 100644
--- a/test/cctest/cctest.gyp
+++ b/test/cctest/cctest.gyp
@@ -30,14 +30,14 @@
'v8_code': 1,
'generated_file': '<(SHARED_INTERMEDIATE_DIR)/resources.cc',
},
- 'includes': ['../../build/toolchain.gypi', '../../build/features.gypi'],
+ 'includes': ['../../gypfiles/toolchain.gypi', '../../gypfiles/features.gypi'],
'targets': [
{
'target_name': 'cctest',
'type': 'executable',
'dependencies': [
'resources',
- '../../tools/gyp/v8.gyp:v8_libplatform',
+ '../../src/v8.gyp:v8_libplatform',
],
'include_dirs': [
'../..',
@@ -51,7 +51,6 @@
'compiler/graph-builder-tester.h',
'compiler/test-basic-block-profiler.cc',
'compiler/test-branch-combine.cc',
- 'compiler/test-changes-lowering.cc',
'compiler/test-code-stub-assembler.cc',
'compiler/test-gap-resolver.cc',
'compiler/test-graph-visualizer.cc',
@@ -68,7 +67,6 @@
'compiler/test-node.cc',
'compiler/test-operator.cc',
'compiler/test-osr.cc',
- 'compiler/test-pipeline.cc',
'compiler/test-representation-change.cc',
'compiler/test-run-bytecode-graph-builder.cc',
'compiler/test-run-calls-to-external-references.cc',
@@ -80,11 +78,13 @@
'compiler/test-run-jsexceptions.cc',
'compiler/test-run-jsobjects.cc',
'compiler/test-run-jsops.cc',
+ 'compiler/test-run-load-store.cc',
'compiler/test-run-machops.cc',
'compiler/test-run-native-calls.cc',
'compiler/test-run-stackcheck.cc',
'compiler/test-run-stubs.cc',
'compiler/test-run-variables.cc',
+ 'compiler/test-run-wasm-machops.cc',
'compiler/test-simplified-lowering.cc',
'cctest.cc',
'expression-type-collector.cc',
@@ -155,9 +155,7 @@
'test-liveedit.cc',
'test-lockers.cc',
'test-log.cc',
- 'test-microtask-delivery.cc',
'test-mementos.cc',
- 'test-object-observe.cc',
'test-parsing.cc',
'test-platform.cc',
'test-profile-generator.cc',
@@ -178,7 +176,6 @@
'test-transitions.cc',
'test-typedarrays.cc',
'test-types.cc',
- 'test-typing-reset.cc',
'test-unbound-queue.cc',
'test-unboxed-doubles.cc',
'test-unique.cc',
@@ -190,9 +187,13 @@
'trace-extension.cc',
'wasm/test-run-wasm.cc',
'wasm/test-run-wasm-64.cc',
+ 'wasm/test-run-wasm-asmjs.cc',
'wasm/test-run-wasm-js.cc',
'wasm/test-run-wasm-module.cc',
'wasm/test-signatures.h',
+ 'wasm/test-wasm-function-name-table.cc',
+ 'wasm/test-wasm-stack.cc',
+ 'wasm/test-wasm-trap-position.cc',
'wasm/wasm-run-utils.h',
],
'conditions': [
@@ -269,6 +270,15 @@
'test-disasm-ppc.cc'
],
}],
+ ['v8_target_arch=="mips"', {
+ 'sources': [ ### gcmole(arch:mips) ###
+ 'test-assembler-mips.cc',
+ 'test-code-stubs.cc',
+ 'test-code-stubs-mips.cc',
+ 'test-disasm-mips.cc',
+ 'test-macro-assembler-mips.cc'
+ ],
+ }],
['v8_target_arch=="mipsel"', {
'sources': [ ### gcmole(arch:mipsel) ###
'test-assembler-mips.cc',
@@ -278,8 +288,17 @@
'test-macro-assembler-mips.cc'
],
}],
+ ['v8_target_arch=="mips64"', {
+ 'sources': [ ### gcmole(arch:mips64) ###
+ 'test-assembler-mips64.cc',
+ 'test-code-stubs.cc',
+ 'test-code-stubs-mips64.cc',
+ 'test-disasm-mips64.cc',
+ 'test-macro-assembler-mips64.cc'
+ ],
+ }],
['v8_target_arch=="mips64el"', {
- 'sources': [
+ 'sources': [ ### gcmole(arch:mips64el) ###
'test-assembler-mips64.cc',
'test-code-stubs.cc',
'test-code-stubs-mips64.cc',
@@ -327,9 +346,9 @@
['component=="shared_library"', {
# cctest can't be built against a shared library, so we need to
# depend on the underlying static target in that case.
- 'dependencies': ['../../tools/gyp/v8.gyp:v8_maybe_snapshot'],
+ 'dependencies': ['../../src/v8.gyp:v8_maybe_snapshot'],
}, {
- 'dependencies': ['../../tools/gyp/v8.gyp:v8'],
+ 'dependencies': ['../../src/v8.gyp:v8'],
}],
],
},
@@ -372,14 +391,14 @@
'target_name': 'generate-bytecode-expectations',
'type': 'executable',
'dependencies': [
- '../../tools/gyp/v8.gyp:v8_libplatform',
+ '../../src/v8.gyp:v8_libplatform',
],
'conditions': [
['component=="shared_library"', {
# Same as cctest, we need to depend on the underlying static target.
- 'dependencies': ['../../tools/gyp/v8.gyp:v8_maybe_snapshot'],
+ 'dependencies': ['../../src/v8.gyp:v8_maybe_snapshot'],
}, {
- 'dependencies': ['../../tools/gyp/v8.gyp:v8'],
+ 'dependencies': ['../../src/v8.gyp:v8'],
}],
],
'include_dirs+': [
@@ -402,7 +421,7 @@
'cctest',
],
'includes': [
- '../../build/isolate.gypi',
+ '../../gypfiles/isolate.gypi',
],
'sources': [
'cctest_exe.isolate',
@@ -415,7 +434,7 @@
'cctest_exe_run',
],
'includes': [
- '../../build/isolate.gypi',
+ '../../gypfiles/isolate.gypi',
],
'sources': [
'cctest.isolate',
diff --git a/test/cctest/cctest.status b/test/cctest/cctest.status
index c992ab6..e1da00d 100644
--- a/test/cctest/cctest.status
+++ b/test/cctest/cctest.status
@@ -132,6 +132,52 @@
'test-debug/CallFunctionInDebugger': [PASS, ['mode == debug', SLOW]],
'test-strings/StringOOM*': [PASS, ['mode == debug', SKIP]],
'test-serialize/CustomSnapshotDataBlobImmortalImmovableRoots': [PASS, ['mode == debug', SKIP]],
+
+ ############################################################################
+ # Ignition
+
+ # TODO(rmcilroy,4680): Related to lack of code flushing. Check failed: !function->shared()->is_compiled() || function->IsOptimized().
+ 'test-heap/TestCodeFlushingPreAged': [PASS, NO_IGNITION],
+ 'test-heap/TestCodeFlushingIncrementalScavenge': [PASS, NO_IGNITION],
+ 'test-heap/TestCodeFlushing': [PASS, NO_IGNITION],
+ 'test-heap/TestCodeFlushingIncremental': [PASS, NO_IGNITION],
+ 'test-heap/TestCodeFlushingIncrementalAbort': [PASS, ['mode == debug or dcheck_always_on == True', NO_IGNITION]],
+
+ # TODO(rmcilroy,4680): Fails to find the correct function name for the
+ # anonymous function. Fails without ignition but with --no-lazy also, so seems
+ # to be an issue when eagerly parsing.
+ 'test-func-name-inference/ReturnAnonymousFunction': [PASS, NO_IGNITION],
+
+ # TODO(mythria,4780): Related to type feedback support for calls.
+ 'test-feedback-vector/VectorCallICStates': [PASS, NO_IGNITION],
+ 'test-compiler/FeedbackVectorPreservedAcrossRecompiles': [PASS, NO_IGNITION],
+ 'test-heap/WeakFunctionInConstructor': [PASS, NO_IGNITION],
+ 'test-heap/IncrementalMarkingClearsMonomorphicConstructor': [PASS, NO_IGNITION],
+ 'test-heap/IncrementalMarkingPreservesMonomorphicConstructor': [PASS, NO_IGNITION],
+ 'test-heap/IncrementalMarkingPreservesMonomorphicCallIC': [PASS, NO_IGNITION],
+ 'test-heap/CellsInOptimizedCodeAreWeak': [PASS, NO_IGNITION],
+
+ # TODO(mythria,4680): Lack of code-ageing in interpreter.
+ 'test-heap/Regress169209': [PASS, NO_IGNITION],
+
+ # TODO(mythria,4680): Lack of code-ageing and/or lack of compilation cache
+ # in interpreter.
+ 'test-heap/CompilationCacheCachingBehavior': [PASS, NO_IGNITION],
+
+ # TODO(mstarzinger,4680): Fails due to the turbo-asm pipeline only being taken
+ # in compiler.cc GetLazyCode for uncompiled code, and no similar path for eager
+ # code.
+ 'test-api/TurboAsmDisablesNeuter': [PASS, NO_IGNITION],
+
+ # TODO(mvstanton,4900): CHECK(!g_function->is_compiled());
+ 'test-heap/TestUseOfIncrementalBarrierOnCompileLazy': [PASS, NO_IGNITION],
+
+ # BUG(rmcilroy,4680): Function is optimized without type feedback and so immediately deopts again, causing check failure in the test.
+ 'test-heap/ResetSharedFunctionInfoCountersDuringIncrementalMarking': [PASS, NO_IGNITION],
+ 'test-heap/ResetSharedFunctionInfoCountersDuringMarkSweep': [PASS, NO_IGNITION],
+
+ # BUG(4751). Flaky with ignition and tsan.
+ 'test-cpu-profiler/JsNativeJsSample': [PASS, ['tsan', NO_IGNITION]],
}], # ALWAYS
##############################################################################
@@ -256,15 +302,14 @@
'test-run-wasm-module/Run_WasmModule_Return114': [SKIP],
'test-run-wasm-module/Run_WasmModule_CheckMemoryIsZero': [SKIP],
'test-run-wasm-module/Run_WasmModule_Global': [SKIP],
- 'test-run-wasm/Run_Wasm_Int32LoadInt16_signext': [SKIP],
- 'test-run-wasm/Run_Wasm_Int32LoadInt16_zeroext': [SKIP],
- 'test-run-wasm/Run_WasmMixedGlobals': [SKIP],
- 'test-run-wasm-64/Run_WasmI64*': [SKIP],
- 'test-run-wasm-64/Run_Wasm_I64*': [SKIP],
- 'test-run-wasm-64/Run_Wasm_LoadStoreI64_sx': [SKIP],
+ 'test-run-wasm/RunWasmCompiled_Int32LoadInt16_signext': [SKIP],
+ 'test-run-wasm/RunWasmCompiled_Int32LoadInt16_zeroext': [SKIP],
+ 'test-run-wasm/RunWasmCompiled_MixedGlobals': [SKIP],
+ 'test-run-wasm-64/RunWasmCompiled_I64*': [SKIP],
+ 'test-run-wasm-64/RunWasmCompiled_LoadStoreI64_sx': [SKIP],
'test-run-wasm-64/Run_TestI64WasmRunner': [SKIP],
- 'test-run-wasm-64/Run_WasmCall_Int64Sub': [SKIP],
- 'test-run-wasm-64/Run_Wasm_MemI64_Sum': [SKIP],
+ 'test-run-wasm-64/RunWasmCompiled_Call_Int64Sub': [SKIP],
+ 'test-run-wasm-64/RunWasmCompiled_MemI64_Sum': [SKIP],
}], # 'byteorder == big'
##############################################################################
@@ -488,12 +533,8 @@
}], # 'arch == ppc64 and simulator_run == True'
##############################################################################
-['ignition == True', {
-
- # TODO(rmcilroy,4680): The function_data field should be a BytecodeArray on interpreter entry
- 'test-api/SetFunctionEntryHook': [FAIL],
-
- # TODO(rmcilroy,4680): Check failed: !function->shared()->is_compiled() || function->IsOptimized().
+['ignition or ignition_turbofan', {
+ # TODO(rmcilroy,4680): Related to lack of code flushing. Check failed: !function->shared()->is_compiled() || function->IsOptimized().
'test-heap/TestCodeFlushingPreAged': [FAIL],
'test-heap/TestCodeFlushingIncrementalScavenge': [FAIL],
'test-heap/TestCodeFlushing': [FAIL],
@@ -530,6 +571,9 @@
# code.
'test-api/TurboAsmDisablesNeuter': [FAIL],
+ # TODO(mvstanton,4900): CHECK(!g_function->is_compiled());
+ 'test-heap/TestUseOfIncrementalBarrierOnCompileLazy': [FAIL],
+
# TODO(rmcilroy,4837): We don't set a LoadContextSlot for a function as
# immutable in the BytecodeGraphBuilder, therefore no inlining happens.
'test-run-inlining/InlineLoopGuardedTwice': [FAIL],
@@ -555,6 +599,9 @@
'test-run-inlining/InlineBuiltin': [FAIL],
'test-run-inlining/InlineTwiceDependent': [FAIL],
'test-run-inlining/SimpleInliningContextDeopt': [FAIL],
-}], # ignition == True
+
+ # BUG(4751). Flaky with ignition and tsan.
+ 'test-cpu-profiler/JsNativeJsSample': [PASS, ['tsan', SKIP]],
+}], # ignition or ignition_turbofan
]
diff --git a/test/cctest/compiler/call-tester.h b/test/cctest/compiler/call-tester.h
index c75bde1..77d2ce1 100644
--- a/test/cctest/compiler/call-tester.h
+++ b/test/cctest/compiler/call-tester.h
@@ -106,12 +106,14 @@
static int64_t Cast(int32_t r) { return static_cast<int64_t>(r); }
};
+#if !V8_TARGET_ARCH_PPC64
template <>
struct ParameterTraits<uint32_t> {
static int64_t Cast(uint32_t r) {
return static_cast<int64_t>(static_cast<int32_t>(r));
}
};
+#endif
#endif // !V8_TARGET_ARCH_64_BIT
diff --git a/test/cctest/compiler/codegen-tester.h b/test/cctest/compiler/codegen-tester.h
index 5d670bf..dbb9a72 100644
--- a/test/cctest/compiler/codegen-tester.h
+++ b/test/cctest/compiler/codegen-tester.h
@@ -65,7 +65,7 @@
Schedule* schedule = this->Export();
CallDescriptor* call_descriptor = this->call_descriptor();
Graph* graph = this->graph();
- CompilationInfo info("testing", main_isolate(), main_zone());
+ CompilationInfo info(ArrayVector("testing"), main_isolate(), main_zone());
code_ = Pipeline::GenerateCodeForTesting(&info, call_descriptor, graph,
schedule);
}
diff --git a/test/cctest/compiler/function-tester.h b/test/cctest/compiler/function-tester.h
index 631bdde..555e049 100644
--- a/test/cctest/compiler/function-tester.h
+++ b/test/cctest/compiler/function-tester.h
@@ -31,7 +31,7 @@
Compile(function);
const uint32_t supported_flags =
CompilationInfo::kFunctionContextSpecializing |
- CompilationInfo::kInliningEnabled | CompilationInfo::kTypingEnabled;
+ CompilationInfo::kInliningEnabled;
CHECK_EQ(0u, flags_ & ~supported_flags);
}
@@ -177,7 +177,7 @@
Handle<JSFunction> Compile(Handle<JSFunction> function) {
Zone zone(function->GetIsolate()->allocator());
ParseInfo parse_info(&zone, function);
- CompilationInfo info(&parse_info);
+ CompilationInfo info(&parse_info, function);
info.MarkAsDeoptimizationEnabled();
CHECK(Parser::ParseStatic(info.parse_info()));
@@ -188,14 +188,14 @@
if (flags_ & CompilationInfo::kInliningEnabled) {
info.MarkAsInliningEnabled();
}
- if (flags_ & CompilationInfo::kTypingEnabled) {
- info.MarkAsTypingEnabled();
+ if (FLAG_turbo_from_bytecode && function->shared()->HasBytecodeArray()) {
+ info.MarkAsOptimizeFromBytecode();
+ } else {
+ CHECK(Compiler::Analyze(info.parse_info()));
+ CHECK(Compiler::EnsureDeoptimizationSupport(&info));
}
- CHECK(Compiler::Analyze(info.parse_info()));
- CHECK(Compiler::EnsureDeoptimizationSupport(&info));
- Pipeline pipeline(&info);
- Handle<Code> code = pipeline.GenerateCode();
+ Handle<Code> code = Pipeline::GenerateCodeForTesting(&info);
CHECK(!code.is_null());
info.dependencies()->Commit(code);
info.context()->native_context()->AddOptimizedCode(*code);
@@ -226,12 +226,10 @@
Handle<JSFunction> CompileGraph(Graph* graph) {
Zone zone(function->GetIsolate()->allocator());
ParseInfo parse_info(&zone, function);
- CompilationInfo info(&parse_info);
+ CompilationInfo info(&parse_info, function);
CHECK(Parser::ParseStatic(info.parse_info()));
info.SetOptimizing();
- CHECK(Compiler::Analyze(info.parse_info()));
- CHECK(Compiler::EnsureDeoptimizationSupport(&info));
Handle<Code> code = Pipeline::GenerateCodeForTesting(&info, graph);
CHECK(!code.is_null());
diff --git a/test/cctest/compiler/graph-builder-tester.h b/test/cctest/compiler/graph-builder-tester.h
index de2713a..e4cccda 100644
--- a/test/cctest/compiler/graph-builder-tester.h
+++ b/test/cctest/compiler/graph-builder-tester.h
@@ -168,11 +168,11 @@
Node* ChangeFloat64ToTagged(Node* a) {
return NewNode(simplified()->ChangeFloat64ToTagged(), a);
}
- Node* ChangeBoolToBit(Node* a) {
- return NewNode(simplified()->ChangeBoolToBit(), a);
+ Node* ChangeTaggedToBit(Node* a) {
+ return NewNode(simplified()->ChangeTaggedToBit(), a);
}
- Node* ChangeBitToBool(Node* a) {
- return NewNode(simplified()->ChangeBitToBool(), a);
+ Node* ChangeBitToTagged(Node* a) {
+ return NewNode(simplified()->ChangeBitToTagged(), a);
}
Node* LoadField(const FieldAccess& access, Node* object) {
@@ -277,7 +277,7 @@
Zone* zone = graph()->zone();
CallDescriptor* desc =
Linkage::GetSimplifiedCDescriptor(zone, this->csig_);
- CompilationInfo info("testing", main_isolate(), main_zone());
+ CompilationInfo info(ArrayVector("testing"), main_isolate(), main_zone());
code_ = Pipeline::GenerateCodeForTesting(&info, desc, graph());
#ifdef ENABLE_DISASSEMBLER
if (!code_.is_null() && FLAG_print_opt_code) {
diff --git a/test/cctest/compiler/test-branch-combine.cc b/test/cctest/compiler/test-branch-combine.cc
index c3b4308..c5c4166 100644
--- a/test/cctest/compiler/test-branch-combine.cc
+++ b/test/cctest/compiler/test-branch-combine.cc
@@ -457,6 +457,27 @@
}
}
+TEST(BranchCombineEffectLevel) {
+ // Test that the load doesn't get folded into the branch, as there's a store
+ // between them. See http://crbug.com/611976.
+ int32_t input = 0;
+
+ RawMachineAssemblerTester<int32_t> m;
+ Node* a = m.LoadFromPointer(&input, MachineType::Int32());
+ Node* compare = m.Word32And(a, m.Int32Constant(1));
+ Node* equal = m.Word32Equal(compare, m.Int32Constant(0));
+ m.StoreToPointer(&input, MachineRepresentation::kWord32, m.Int32Constant(1));
+
+ RawMachineLabel blocka, blockb;
+ m.Branch(equal, &blocka, &blockb);
+ m.Bind(&blocka);
+ m.Return(m.Int32Constant(42));
+ m.Bind(&blockb);
+ m.Return(m.Int32Constant(0));
+
+ CHECK_EQ(42, m.Call());
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
diff --git a/test/cctest/compiler/test-changes-lowering.cc b/test/cctest/compiler/test-changes-lowering.cc
deleted file mode 100644
index ddeabe4..0000000
--- a/test/cctest/compiler/test-changes-lowering.cc
+++ /dev/null
@@ -1,290 +0,0 @@
-// Copyright 2014 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <limits>
-
-#include "src/ast/scopes.h"
-#include "src/compiler/change-lowering.h"
-#include "src/compiler/control-builders.h"
-#include "src/compiler/js-graph.h"
-#include "src/compiler/node-properties.h"
-#include "src/compiler/pipeline.h"
-#include "src/compiler/select-lowering.h"
-#include "src/compiler/simplified-lowering.h"
-#include "src/compiler/typer.h"
-#include "src/compiler/verifier.h"
-#include "src/execution.h"
-#include "src/globals.h"
-#include "src/parsing/parser.h"
-#include "src/parsing/rewriter.h"
-#include "test/cctest/cctest.h"
-#include "test/cctest/compiler/codegen-tester.h"
-#include "test/cctest/compiler/function-tester.h"
-#include "test/cctest/compiler/graph-builder-tester.h"
-#include "test/cctest/compiler/value-helper.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-template <typename ReturnType>
-class ChangesLoweringTester : public GraphBuilderTester<ReturnType> {
- public:
- explicit ChangesLoweringTester(MachineType p0 = MachineType::None())
- : GraphBuilderTester<ReturnType>(p0),
- javascript(this->zone()),
- jsgraph(this->isolate(), this->graph(), this->common(), &javascript,
- nullptr, this->machine()),
- function(Handle<JSFunction>::null()) {}
-
- JSOperatorBuilder javascript;
- JSGraph jsgraph;
- Handle<JSFunction> function;
-
- Node* start() { return this->graph()->start(); }
-
- template <typename T>
- T* CallWithPotentialGC() {
- // TODO(titzer): we wrap the code in a JSFunction here to reuse the
- // JSEntryStub; that could be done with a special prologue or other stub.
- if (function.is_null()) {
- function = FunctionTester::ForMachineGraph(this->graph());
- }
- Handle<Object>* args = NULL;
- MaybeHandle<Object> result =
- Execution::Call(this->isolate(), function, factory()->undefined_value(),
- 0, args, false);
- return T::cast(*result.ToHandleChecked());
- }
-
- void StoreFloat64(Node* node, double* ptr) {
- Node* ptr_node = this->PointerConstant(ptr);
- this->Store(MachineType::Float64(), ptr_node, node);
- }
-
- Node* LoadInt32(int32_t* ptr) {
- Node* ptr_node = this->PointerConstant(ptr);
- return this->Load(MachineType::Int32(), ptr_node);
- }
-
- Node* LoadUint32(uint32_t* ptr) {
- Node* ptr_node = this->PointerConstant(ptr);
- return this->Load(MachineType::Uint32(), ptr_node);
- }
-
- Node* LoadFloat64(double* ptr) {
- Node* ptr_node = this->PointerConstant(ptr);
- return this->Load(MachineType::Float64(), ptr_node);
- }
-
- void CheckNumber(double expected, Object* number) {
- CHECK(this->isolate()->factory()->NewNumber(expected)->SameValue(number));
- }
-
- void BuildAndLower(const Operator* op) {
- // We build a graph by hand here, because the raw machine assembler
- // does not add the correct control and effect nodes.
- Node* p0 = this->Parameter(0);
- Node* change = this->graph()->NewNode(op, p0);
- Node* ret = this->graph()->NewNode(this->common()->Return(), change,
- this->start(), this->start());
- Node* end = this->graph()->NewNode(this->common()->End(1), ret);
- this->graph()->SetEnd(end);
- LowerChange(change);
- }
-
- void BuildStoreAndLower(const Operator* op, const Operator* store_op,
- void* location) {
- // We build a graph by hand here, because the raw machine assembler
- // does not add the correct control and effect nodes.
- Node* p0 = this->Parameter(0);
- Node* change = this->graph()->NewNode(op, p0);
- Node* store = this->graph()->NewNode(
- store_op, this->PointerConstant(location), this->Int32Constant(0),
- change, this->start(), this->start());
- Node* ret = this->graph()->NewNode(
- this->common()->Return(), this->Int32Constant(0), store, this->start());
- Node* end = this->graph()->NewNode(this->common()->End(1), ret);
- this->graph()->SetEnd(end);
- LowerChange(change);
- }
-
- void BuildLoadAndLower(const Operator* op, const Operator* load_op,
- void* location) {
- // We build a graph by hand here, because the raw machine assembler
- // does not add the correct control and effect nodes.
- Node* load = this->graph()->NewNode(
- load_op, this->PointerConstant(location), this->Int32Constant(0),
- this->start(), this->start());
- Node* change = this->graph()->NewNode(op, load);
- Node* ret = this->graph()->NewNode(this->common()->Return(), change,
- this->start(), this->start());
- Node* end = this->graph()->NewNode(this->common()->End(1), ret);
- this->graph()->SetEnd(end);
- LowerChange(change);
- }
-
- void LowerChange(Node* change) {
- // Run the graph reducer with changes lowering on a single node.
- Typer typer(this->isolate(), this->graph());
- typer.Run();
- ChangeLowering change_lowering(&jsgraph);
- SelectLowering select_lowering(this->graph(), this->common());
- GraphReducer reducer(this->zone(), this->graph());
- reducer.AddReducer(&change_lowering);
- reducer.AddReducer(&select_lowering);
- reducer.ReduceNode(change);
- Verifier::Run(this->graph(), Verifier::UNTYPED);
- }
-
- Factory* factory() { return this->isolate()->factory(); }
- Heap* heap() { return this->isolate()->heap(); }
-};
-
-
-TEST(RunChangeTaggedToInt32) {
- // Build and lower a graph by hand.
- ChangesLoweringTester<int32_t> t(MachineType::AnyTagged());
- t.BuildAndLower(t.simplified()->ChangeTaggedToInt32());
-
- FOR_INT32_INPUTS(i) {
- int32_t input = *i;
-
- if (Smi::IsValid(input)) {
- int32_t result = t.Call(Smi::FromInt(input));
- CHECK_EQ(input, result);
- }
-
- {
- Handle<Object> number = t.factory()->NewNumber(input);
- int32_t result = t.Call(*number);
- CHECK_EQ(input, result);
- }
-
- {
- Handle<HeapNumber> number = t.factory()->NewHeapNumber(input);
- int32_t result = t.Call(*number);
- CHECK_EQ(input, result);
- }
- }
-}
-
-
-TEST(RunChangeTaggedToUint32) {
- // Build and lower a graph by hand.
- ChangesLoweringTester<uint32_t> t(MachineType::AnyTagged());
- t.BuildAndLower(t.simplified()->ChangeTaggedToUint32());
-
- FOR_UINT32_INPUTS(i) {
- uint32_t input = *i;
-
- if (Smi::IsValid(input)) {
- uint32_t result = t.Call(Smi::FromInt(input));
- CHECK_EQ(static_cast<int32_t>(input), static_cast<int32_t>(result));
- }
-
- {
- Handle<Object> number = t.factory()->NewNumber(input);
- uint32_t result = t.Call(*number);
- CHECK_EQ(static_cast<int32_t>(input), static_cast<int32_t>(result));
- }
-
- {
- Handle<HeapNumber> number = t.factory()->NewHeapNumber(input);
- uint32_t result = t.Call(*number);
- CHECK_EQ(static_cast<int32_t>(input), static_cast<int32_t>(result));
- }
- }
-}
-
-
-TEST(RunChangeTaggedToFloat64) {
- ChangesLoweringTester<int32_t> t(MachineType::AnyTagged());
- double result;
-
- t.BuildStoreAndLower(t.simplified()->ChangeTaggedToFloat64(),
- t.machine()->Store(StoreRepresentation(
- MachineRepresentation::kFloat64, kNoWriteBarrier)),
- &result);
-
- {
- FOR_INT32_INPUTS(i) {
- int32_t input = *i;
-
- if (Smi::IsValid(input)) {
- t.Call(Smi::FromInt(input));
- CHECK_EQ(input, static_cast<int32_t>(result));
- }
-
- {
- Handle<Object> number = t.factory()->NewNumber(input);
- t.Call(*number);
- CHECK_EQ(input, static_cast<int32_t>(result));
- }
-
- {
- Handle<HeapNumber> number = t.factory()->NewHeapNumber(input);
- t.Call(*number);
- CHECK_EQ(input, static_cast<int32_t>(result));
- }
- }
- }
-
- {
- FOR_FLOAT64_INPUTS(i) {
- double input = *i;
- {
- Handle<Object> number = t.factory()->NewNumber(input);
- t.Call(*number);
- CHECK_DOUBLE_EQ(input, result);
- }
-
- {
- Handle<HeapNumber> number = t.factory()->NewHeapNumber(input);
- t.Call(*number);
- CHECK_DOUBLE_EQ(input, result);
- }
- }
- }
-}
-
-
-TEST(RunChangeBoolToBit) {
- ChangesLoweringTester<int32_t> t(MachineType::AnyTagged());
- t.BuildAndLower(t.simplified()->ChangeBoolToBit());
-
- {
- Object* true_obj = t.heap()->true_value();
- int32_t result = t.Call(true_obj);
- CHECK_EQ(1, result);
- }
-
- {
- Object* false_obj = t.heap()->false_value();
- int32_t result = t.Call(false_obj);
- CHECK_EQ(0, result);
- }
-}
-
-
-TEST(RunChangeBitToBool) {
- ChangesLoweringTester<Object*> t(MachineType::Int32());
- t.BuildAndLower(t.simplified()->ChangeBitToBool());
-
- {
- Object* result = t.Call(1);
- Object* true_obj = t.heap()->true_value();
- CHECK_EQ(true_obj, result);
- }
-
- {
- Object* result = t.Call(0);
- Object* false_obj = t.heap()->false_value();
- CHECK_EQ(false_obj, result);
- }
-}
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
diff --git a/test/cctest/compiler/test-code-stub-assembler.cc b/test/cctest/compiler/test-code-stub-assembler.cc
index ff02cc9..37ba9e9 100644
--- a/test/cctest/compiler/test-code-stub-assembler.cc
+++ b/test/cctest/compiler/test-code-stub-assembler.cc
@@ -246,8 +246,9 @@
CodeStubAssemblerTester m(isolate, descriptor);
Handle<FixedArray> array = isolate->factory()->NewFixedArray(5);
array->set(4, Smi::FromInt(733));
- m.Return(m.LoadFixedArrayElementSmiIndex(m.HeapConstant(array),
- m.SmiTag(m.Int32Constant(4))));
+ m.Return(m.LoadFixedArrayElement(m.HeapConstant(array),
+ m.SmiTag(m.Int32Constant(4)), 0,
+ CodeStubAssembler::SMI_PARAMETERS));
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
MaybeHandle<Object> result = ft.Call();
@@ -361,6 +362,33 @@
USE(m.GenerateCode());
}
+TEST(TestToConstant) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeStubAssemblerTester m(isolate, descriptor);
+ int32_t value32;
+ int64_t value64;
+ Node* a = m.Int32Constant(5);
+ CHECK(m.ToInt32Constant(a, value32));
+ CHECK(m.ToInt64Constant(a, value64));
+
+ a = m.Int64Constant(static_cast<int64_t>(1) << 32);
+ CHECK(!m.ToInt32Constant(a, value32));
+ CHECK(m.ToInt64Constant(a, value64));
+
+ a = m.Int64Constant(13);
+ CHECK(m.ToInt32Constant(a, value32));
+ CHECK(m.ToInt64Constant(a, value64));
+
+ a = m.UndefinedConstant();
+ CHECK(!m.ToInt32Constant(a, value32));
+ CHECK(!m.ToInt64Constant(a, value64));
+
+ a = m.UndefinedConstant();
+ CHECK(!m.ToInt32Constant(a, value32));
+ CHECK(!m.ToInt64Constant(a, value64));
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
diff --git a/test/cctest/compiler/test-gap-resolver.cc b/test/cctest/compiler/test-gap-resolver.cc
index 7f85088..9781aeb 100644
--- a/test/cctest/compiler/test-gap-resolver.cc
+++ b/test/cctest/compiler/test-gap-resolver.cc
@@ -81,7 +81,7 @@
if (!is_constant) {
if (op.IsRegister()) {
index = LocationOperand::cast(op).GetRegister().code();
- } else if (op.IsDoubleRegister()) {
+ } else if (op.IsFPRegister()) {
index = LocationOperand::cast(op).GetDoubleRegister().code();
} else {
index = LocationOperand::cast(op).index();
diff --git a/test/cctest/compiler/test-linkage.cc b/test/cctest/compiler/test-linkage.cc
index 0cbdb4c..dc83f4d 100644
--- a/test/cctest/compiler/test-linkage.cc
+++ b/test/cctest/compiler/test-linkage.cc
@@ -43,7 +43,7 @@
HandleAndZoneScope handles;
Handle<JSFunction> function = Compile("a + b");
ParseInfo parse_info(handles.main_zone(), function);
- CompilationInfo info(&parse_info);
+ CompilationInfo info(&parse_info, function);
CallDescriptor* descriptor = Linkage::ComputeIncoming(info.zone(), &info);
CHECK(descriptor);
}
@@ -59,7 +59,7 @@
Handle<JSFunction>::cast(v8::Utils::OpenHandle(
*v8::Local<v8::Function>::Cast(CompileRun(sources[i]))));
ParseInfo parse_info(handles.main_zone(), function);
- CompilationInfo info(&parse_info);
+ CompilationInfo info(&parse_info, function);
CallDescriptor* descriptor = Linkage::ComputeIncoming(info.zone(), &info);
CHECK(descriptor);
@@ -75,7 +75,7 @@
HandleAndZoneScope handles;
Handle<JSFunction> function = Compile("a + c");
ParseInfo parse_info(handles.main_zone(), function);
- CompilationInfo info(&parse_info);
+ CompilationInfo info(&parse_info, function);
for (int i = 0; i < 32; i++) {
CallDescriptor* descriptor = Linkage::GetJSCallDescriptor(
@@ -98,7 +98,8 @@
Isolate* isolate = CcTest::InitIsolateOnce();
Zone zone(isolate->allocator());
ToNumberStub stub(isolate);
- CompilationInfo info("test", isolate, &zone, Code::ComputeFlags(Code::STUB));
+ CompilationInfo info(ArrayVector("test"), isolate, &zone,
+ Code::ComputeFlags(Code::STUB));
CallInterfaceDescriptor interface_descriptor =
stub.GetCallInterfaceDescriptor();
CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
diff --git a/test/cctest/compiler/test-loop-assignment-analysis.cc b/test/cctest/compiler/test-loop-assignment-analysis.cc
index 69f5e15..eafd0ec 100644
--- a/test/cctest/compiler/test-loop-assignment-analysis.cc
+++ b/test/cctest/compiler/test-loop-assignment-analysis.cc
@@ -31,7 +31,7 @@
void CheckLoopAssignedCount(int expected, const char* var_name) {
// TODO(titzer): don't scope analyze every single time.
ParseInfo parse_info(main_zone(), function);
- CompilationInfo info(&parse_info);
+ CompilationInfo info(&parse_info, function);
CHECK(Parser::ParseStatic(&parse_info));
CHECK(Rewriter::Rewrite(&parse_info));
diff --git a/test/cctest/compiler/test-multiple-return.cc b/test/cctest/compiler/test-multiple-return.cc
index 2108ab1..53bae5e 100644
--- a/test/cctest/compiler/test-multiple-return.cc
+++ b/test/cctest/compiler/test-multiple-return.cc
@@ -85,7 +85,8 @@
Node* mul = m.Int32Mul(p0, p1);
m.Return(add, sub, mul);
- CompilationInfo info("testing", handles.main_isolate(), handles.main_zone());
+ CompilationInfo info(ArrayVector("testing"), handles.main_isolate(),
+ handles.main_zone());
Handle<Code> code =
Pipeline::GenerateCodeForTesting(&info, desc, m.graph(), m.Export());
#ifdef ENABLE_DISASSEMBLER
diff --git a/test/cctest/compiler/test-pipeline.cc b/test/cctest/compiler/test-pipeline.cc
deleted file mode 100644
index 35e3427..0000000
--- a/test/cctest/compiler/test-pipeline.cc
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2013 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "src/compiler.h"
-#include "src/compiler/pipeline.h"
-#include "src/handles.h"
-#include "src/parsing/parser.h"
-#include "test/cctest/cctest.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-static void RunPipeline(Zone* zone, const char* source) {
- Handle<JSFunction> function = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
- *v8::Local<v8::Function>::Cast(CompileRun(source))));
- ParseInfo parse_info(zone, function);
- CHECK(Compiler::ParseAndAnalyze(&parse_info));
- CompilationInfo info(&parse_info);
- info.SetOptimizing();
-
- Pipeline pipeline(&info);
- Handle<Code> code = pipeline.GenerateCode();
- CHECK(!code.is_null());
-}
-
-
-TEST(PipelineTyped) {
- HandleAndZoneScope handles;
- FLAG_turbo_types = true;
- RunPipeline(handles.main_zone(), "(function(a,b) { return a + b; })");
-}
-
-
-TEST(PipelineGeneric) {
- HandleAndZoneScope handles;
- FLAG_turbo_types = false;
- RunPipeline(handles.main_zone(), "(function(a,b) { return a + b; })");
-}
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
diff --git a/test/cctest/compiler/test-representation-change.cc b/test/cctest/compiler/test-representation-change.cc
index 7e75bf8..76aa390 100644
--- a/test/cctest/compiler/test-representation-change.cc
+++ b/test/cctest/compiler/test-representation-change.cc
@@ -439,24 +439,45 @@
TEST(SingleChanges) {
- CheckChange(IrOpcode::kChangeBoolToBit, MachineRepresentation::kTagged,
+ CheckChange(IrOpcode::kChangeTaggedToBit, MachineRepresentation::kTagged,
Type::None(), MachineRepresentation::kBit);
- CheckChange(IrOpcode::kChangeBitToBool, MachineRepresentation::kBit,
+ CheckChange(IrOpcode::kChangeBitToTagged, MachineRepresentation::kBit,
Type::None(), MachineRepresentation::kTagged);
+ CheckChange(IrOpcode::kChangeInt31ToTaggedSigned,
+ MachineRepresentation::kWord32, Type::Signed31(),
+ MachineRepresentation::kTagged);
CheckChange(IrOpcode::kChangeInt32ToTagged, MachineRepresentation::kWord32,
Type::Signed32(), MachineRepresentation::kTagged);
CheckChange(IrOpcode::kChangeUint32ToTagged, MachineRepresentation::kWord32,
Type::Unsigned32(), MachineRepresentation::kTagged);
CheckChange(IrOpcode::kChangeFloat64ToTagged, MachineRepresentation::kFloat64,
- Type::None(), MachineRepresentation::kTagged);
+ Type::Number(), MachineRepresentation::kTagged);
+ CheckTwoChanges(IrOpcode::kChangeFloat64ToInt32,
+ IrOpcode::kChangeInt31ToTaggedSigned,
+ MachineRepresentation::kFloat64, Type::Signed31(),
+ MachineRepresentation::kTagged);
+ CheckTwoChanges(IrOpcode::kChangeFloat64ToInt32,
+ IrOpcode::kChangeInt32ToTagged,
+ MachineRepresentation::kFloat64, Type::Signed32(),
+ MachineRepresentation::kTagged);
+ CheckTwoChanges(IrOpcode::kChangeFloat64ToUint32,
+ IrOpcode::kChangeUint32ToTagged,
+ MachineRepresentation::kFloat64, Type::Unsigned32(),
+ MachineRepresentation::kTagged);
CheckChange(IrOpcode::kChangeTaggedToInt32, MachineRepresentation::kTagged,
Type::Signed32(), MachineRepresentation::kWord32);
CheckChange(IrOpcode::kChangeTaggedToUint32, MachineRepresentation::kTagged,
Type::Unsigned32(), MachineRepresentation::kWord32);
CheckChange(IrOpcode::kChangeTaggedToFloat64, MachineRepresentation::kTagged,
- Type::None(), MachineRepresentation::kFloat64);
+ Type::Number(), MachineRepresentation::kFloat64);
+ CheckChange(IrOpcode::kChangeTaggedToFloat64, MachineRepresentation::kTagged,
+ Type::NumberOrUndefined(), MachineRepresentation::kFloat64);
+ CheckTwoChanges(IrOpcode::kChangeTaggedSignedToInt32,
+ IrOpcode::kChangeInt32ToFloat64,
+ MachineRepresentation::kTagged, Type::TaggedSigned(),
+ MachineRepresentation::kFloat64);
// Int32,Uint32 <-> Float64 are actually machine conversions.
CheckChange(IrOpcode::kChangeInt32ToFloat64, MachineRepresentation::kWord32,
@@ -513,7 +534,7 @@
Type::None(), MachineRepresentation::kFloat64);
CheckChange(IrOpcode::kChangeFloat64ToInt32, MachineRepresentation::kFloat64,
Type::Signed32(), MachineRepresentation::kWord32);
- CheckChange(IrOpcode::kTruncateFloat64ToInt32,
+ CheckChange(IrOpcode::kTruncateFloat64ToWord32,
MachineRepresentation::kFloat64, Type::Number(),
MachineRepresentation::kWord32);
@@ -522,7 +543,7 @@
MachineRepresentation::kWord32, Type::None(),
MachineRepresentation::kFloat32);
CheckTwoChanges(IrOpcode::kChangeFloat32ToFloat64,
- IrOpcode::kTruncateFloat64ToInt32,
+ IrOpcode::kTruncateFloat64ToWord32,
MachineRepresentation::kFloat32, Type::Number(),
MachineRepresentation::kWord32);
}
diff --git a/test/cctest/compiler/test-run-bytecode-graph-builder.cc b/test/cctest/compiler/test-run-bytecode-graph-builder.cc
index c32f923..024747f 100644
--- a/test/cctest/compiler/test-run-bytecode-graph-builder.cc
+++ b/test/cctest/compiler/test-run-bytecode-graph-builder.cc
@@ -125,11 +125,11 @@
// having to instantiate a ParseInfo first. Fix this!
ParseInfo parse_info(zone_, function);
- CompilationInfo compilation_info(&parse_info);
+ CompilationInfo compilation_info(&parse_info, function);
compilation_info.SetOptimizing();
compilation_info.MarkAsDeoptimizationEnabled();
- compiler::Pipeline pipeline(&compilation_info);
- Handle<Code> code = pipeline.GenerateCode();
+ compilation_info.MarkAsOptimizeFromBytecode();
+ Handle<Code> code = Pipeline::GenerateCodeForTesting(&compilation_info);
function->ReplaceCode(*code);
return function;
diff --git a/test/cctest/compiler/test-run-calls-to-external-references.cc b/test/cctest/compiler/test-run-calls-to-external-references.cc
index 3b79cd8..430e238 100644
--- a/test/cctest/compiler/test-run-calls-to-external-references.cc
+++ b/test/cctest/compiler/test-run-calls-to-external-references.cc
@@ -2,6 +2,7 @@
// source code is governed by a BSD-style license that can be found in the
// LICENSE file.
+#include "src/wasm/wasm-external-refs.h"
#include "test/cctest/cctest.h"
#include "test/cctest/compiler/codegen-tester.h"
#include "test/cctest/compiler/value-helper.h"
@@ -10,521 +11,234 @@
namespace internal {
namespace compiler {
-template <typename T>
-void TestExternalReferenceRoundingFunction(
- BufferedRawMachineAssemblerTester<int32_t>* m, ExternalReference ref,
- T (*comparison)(T)) {
- T parameter;
+template <typename P>
+void TestExternalReference(BufferedRawMachineAssemblerTester<int32_t>* m,
+ ExternalReference ref, void (*comparison)(P*),
+ P param) {
+ P comparison_param = param;
Node* function = m->ExternalConstant(ref);
m->CallCFunction1(MachineType::Pointer(), MachineType::Pointer(), function,
- m->PointerConstant(¶meter));
+ m->PointerConstant(¶m));
m->Return(m->Int32Constant(4356));
- FOR_FLOAT64_INPUTS(i) {
- parameter = *i;
- m->Call();
- CHECK_DOUBLE_EQ(comparison(*i), parameter);
- }
+
+ m->Call();
+ comparison(&comparison_param);
+
+ CHECK_EQ(comparison_param, param);
+}
+
+template <typename P1, typename P2>
+void TestExternalReference(BufferedRawMachineAssemblerTester<int32_t>* m,
+ ExternalReference ref, void (*comparison)(P1*, P2*),
+ P1 param1, P2 param2) {
+ P1 comparison_param1 = param1;
+ P2 comparison_param2 = param2;
+
+ Node* function = m->ExternalConstant(ref);
+ m->CallCFunction2(MachineType::Pointer(), MachineType::Pointer(),
+ MachineType::Pointer(), function,
+ m->PointerConstant(¶m1), m->PointerConstant(¶m2));
+ m->Return(m->Int32Constant(4356));
+
+ m->Call();
+ comparison(&comparison_param1, &comparison_param2);
+
+ CHECK_EQ(comparison_param1, param1);
+ CHECK_EQ(comparison_param2, param2);
+}
+
+template <typename R, typename P>
+void TestExternalReference(BufferedRawMachineAssemblerTester<R>* m,
+ ExternalReference ref, R (*comparison)(P*),
+ P param) {
+ P comparison_param = param;
+
+ Node* function = m->ExternalConstant(ref);
+ m->Return(m->CallCFunction1(MachineType::Pointer(), MachineType::Pointer(),
+ function, m->PointerConstant(¶m)));
+
+ CHECK_EQ(comparison(&comparison_param), m->Call());
+
+ CHECK_EQ(comparison_param, param);
+}
+
+template <typename R, typename P1, typename P2>
+void TestExternalReference(BufferedRawMachineAssemblerTester<R>* m,
+ ExternalReference ref, R (*comparison)(P1*, P2*),
+ P1 param1, P2 param2) {
+ P1 comparison_param1 = param1;
+ P2 comparison_param2 = param2;
+
+ Node* function = m->ExternalConstant(ref);
+ m->Return(m->CallCFunction2(
+ MachineType::Pointer(), MachineType::Pointer(), MachineType::Pointer(),
+ function, m->PointerConstant(¶m1), m->PointerConstant(¶m2)));
+
+ CHECK_EQ(comparison(&comparison_param1, &comparison_param2), m->Call());
+
+ CHECK_EQ(comparison_param1, param1);
+ CHECK_EQ(comparison_param2, param2);
}
TEST(RunCallF32Trunc) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_f32_trunc(m.isolate());
- TestExternalReferenceRoundingFunction<float>(&m, ref, truncf);
+ TestExternalReference(&m, ref, wasm::f32_trunc_wrapper, 1.25f);
}
TEST(RunCallF32Floor) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_f32_floor(m.isolate());
- TestExternalReferenceRoundingFunction<float>(&m, ref, floorf);
+ TestExternalReference(&m, ref, wasm::f32_floor_wrapper, 1.25f);
}
TEST(RunCallF32Ceil) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_f32_ceil(m.isolate());
- TestExternalReferenceRoundingFunction<float>(&m, ref, ceilf);
+ TestExternalReference(&m, ref, wasm::f32_ceil_wrapper, 1.25f);
}
TEST(RunCallF32RoundTiesEven) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_f32_nearest_int(m.isolate());
- TestExternalReferenceRoundingFunction<float>(&m, ref, nearbyintf);
+ TestExternalReference(&m, ref, wasm::f32_nearest_int_wrapper, 1.25f);
}
TEST(RunCallF64Trunc) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_f64_trunc(m.isolate());
- TestExternalReferenceRoundingFunction<double>(&m, ref, trunc);
+ TestExternalReference(&m, ref, wasm::f64_trunc_wrapper, 1.25);
}
TEST(RunCallF64Floor) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_f64_floor(m.isolate());
- TestExternalReferenceRoundingFunction<double>(&m, ref, floor);
+ TestExternalReference(&m, ref, wasm::f64_floor_wrapper, 1.25);
}
TEST(RunCallF64Ceil) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_f64_ceil(m.isolate());
- TestExternalReferenceRoundingFunction<double>(&m, ref, ceil);
+ TestExternalReference(&m, ref, wasm::f64_ceil_wrapper, 1.25);
}
TEST(RunCallF64RoundTiesEven) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_f64_nearest_int(m.isolate());
- TestExternalReferenceRoundingFunction<double>(&m, ref, nearbyint);
+ TestExternalReference(&m, ref, wasm::f64_nearest_int_wrapper, 1.25);
}
TEST(RunCallInt64ToFloat32) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_int64_to_float32(m.isolate());
-
- int64_t input;
- float output;
-
- Node* function = m.ExternalConstant(ref);
- m.CallCFunction2(MachineType::Pointer(), MachineType::Pointer(),
- MachineType::Pointer(), function, m.PointerConstant(&input),
- m.PointerConstant(&output));
- m.Return(m.Int32Constant(4356));
- FOR_INT64_INPUTS(i) {
- input = *i;
- m.Call();
- CHECK_FLOAT_EQ(static_cast<float>(*i), output);
- }
+ TestExternalReference(&m, ref, wasm::int64_to_float32_wrapper, int64_t(-2124),
+ 1.25f);
}
TEST(RunCallUint64ToFloat32) {
- struct {
- uint64_t input;
- uint32_t expected;
- } values[] = {{0x0, 0x0},
- {0x1, 0x3f800000},
- {0xffffffff, 0x4f800000},
- {0x1b09788b, 0x4dd84bc4},
- {0x4c5fce8, 0x4c98bf9d},
- {0xcc0de5bf, 0x4f4c0de6},
- {0x2, 0x40000000},
- {0x3, 0x40400000},
- {0x4, 0x40800000},
- {0x5, 0x40a00000},
- {0x8, 0x41000000},
- {0x9, 0x41100000},
- {0xffffffffffffffff, 0x5f800000},
- {0xfffffffffffffffe, 0x5f800000},
- {0xfffffffffffffffd, 0x5f800000},
- {0x0, 0x0},
- {0x100000000, 0x4f800000},
- {0xffffffff00000000, 0x5f800000},
- {0x1b09788b00000000, 0x5dd84bc4},
- {0x4c5fce800000000, 0x5c98bf9d},
- {0xcc0de5bf00000000, 0x5f4c0de6},
- {0x200000000, 0x50000000},
- {0x300000000, 0x50400000},
- {0x400000000, 0x50800000},
- {0x500000000, 0x50a00000},
- {0x800000000, 0x51000000},
- {0x900000000, 0x51100000},
- {0x273a798e187937a3, 0x5e1ce9e6},
- {0xece3af835495a16b, 0x5f6ce3b0},
- {0xb668ecc11223344, 0x5d3668ed},
- {0x9e, 0x431e0000},
- {0x43, 0x42860000},
- {0xaf73, 0x472f7300},
- {0x116b, 0x458b5800},
- {0x658ecc, 0x4acb1d98},
- {0x2b3b4c, 0x4a2ced30},
- {0x88776655, 0x4f087766},
- {0x70000000, 0x4ee00000},
- {0x7200000, 0x4ce40000},
- {0x7fffffff, 0x4f000000},
- {0x56123761, 0x4eac246f},
- {0x7fffff00, 0x4efffffe},
- {0x761c4761eeeeeeee, 0x5eec388f},
- {0x80000000eeeeeeee, 0x5f000000},
- {0x88888888dddddddd, 0x5f088889},
- {0xa0000000dddddddd, 0x5f200000},
- {0xddddddddaaaaaaaa, 0x5f5dddde},
- {0xe0000000aaaaaaaa, 0x5f600000},
- {0xeeeeeeeeeeeeeeee, 0x5f6eeeef},
- {0xfffffffdeeeeeeee, 0x5f800000},
- {0xf0000000dddddddd, 0x5f700000},
- {0x7fffffdddddddd, 0x5b000000},
- {0x3fffffaaaaaaaa, 0x5a7fffff},
- {0x1fffffaaaaaaaa, 0x59fffffd},
- {0xfffff, 0x497ffff0},
- {0x7ffff, 0x48ffffe0},
- {0x3ffff, 0x487fffc0},
- {0x1ffff, 0x47ffff80},
- {0xffff, 0x477fff00},
- {0x7fff, 0x46fffe00},
- {0x3fff, 0x467ffc00},
- {0x1fff, 0x45fff800},
- {0xfff, 0x457ff000},
- {0x7ff, 0x44ffe000},
- {0x3ff, 0x447fc000},
- {0x1ff, 0x43ff8000},
- {0x3fffffffffff, 0x56800000},
- {0x1fffffffffff, 0x56000000},
- {0xfffffffffff, 0x55800000},
- {0x7ffffffffff, 0x55000000},
- {0x3ffffffffff, 0x54800000},
- {0x1ffffffffff, 0x54000000},
- {0x8000008000000000, 0x5f000000},
- {0x8000008000000001, 0x5f000001},
- {0x8000008000000002, 0x5f000001},
- {0x8000008000000004, 0x5f000001},
- {0x8000008000000008, 0x5f000001},
- {0x8000008000000010, 0x5f000001},
- {0x8000008000000020, 0x5f000001},
- {0x8000009000000000, 0x5f000001},
- {0x800000a000000000, 0x5f000001},
- {0x8000008000100000, 0x5f000001},
- {0x8000000000000400, 0x5f000000},
- {0x8000000000000401, 0x5f000000}};
-
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref =
ExternalReference::wasm_uint64_to_float32(m.isolate());
-
- uint64_t input;
- float output;
-
- Node* function = m.ExternalConstant(ref);
- m.CallCFunction2(MachineType::Pointer(), MachineType::Pointer(),
- MachineType::Pointer(), function, m.PointerConstant(&input),
- m.PointerConstant(&output));
- m.Return(m.Int32Constant(4356));
-
- for (size_t i = 0; i < arraysize(values); i++) {
- input = values[i].input;
- m.Call();
- CHECK_EQ(values[i].expected, bit_cast<uint32_t>(output));
- }
+ TestExternalReference(&m, ref, wasm::uint64_to_float32_wrapper,
+ uint64_t(2124), 1.25f);
}
TEST(RunCallInt64ToFloat64) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_int64_to_float64(m.isolate());
-
- int64_t input;
- double output;
-
- Node* function = m.ExternalConstant(ref);
- m.CallCFunction2(MachineType::Pointer(), MachineType::Pointer(),
- MachineType::Pointer(), function, m.PointerConstant(&input),
- m.PointerConstant(&output));
- m.Return(m.Int32Constant(4356));
- FOR_INT64_INPUTS(i) {
- input = *i;
- m.Call();
- CHECK_DOUBLE_EQ(static_cast<double>(*i), output);
- }
+ TestExternalReference(&m, ref, wasm::int64_to_float64_wrapper, int64_t(2124),
+ 1.25);
}
TEST(RunCallUint64ToFloat64) {
- struct {
- uint64_t input;
- uint64_t expected;
- } values[] = {{0x0, 0x0},
- {0x1, 0x3ff0000000000000},
- {0xffffffff, 0x41efffffffe00000},
- {0x1b09788b, 0x41bb09788b000000},
- {0x4c5fce8, 0x419317f3a0000000},
- {0xcc0de5bf, 0x41e981bcb7e00000},
- {0x2, 0x4000000000000000},
- {0x3, 0x4008000000000000},
- {0x4, 0x4010000000000000},
- {0x5, 0x4014000000000000},
- {0x8, 0x4020000000000000},
- {0x9, 0x4022000000000000},
- {0xffffffffffffffff, 0x43f0000000000000},
- {0xfffffffffffffffe, 0x43f0000000000000},
- {0xfffffffffffffffd, 0x43f0000000000000},
- {0x100000000, 0x41f0000000000000},
- {0xffffffff00000000, 0x43efffffffe00000},
- {0x1b09788b00000000, 0x43bb09788b000000},
- {0x4c5fce800000000, 0x439317f3a0000000},
- {0xcc0de5bf00000000, 0x43e981bcb7e00000},
- {0x200000000, 0x4200000000000000},
- {0x300000000, 0x4208000000000000},
- {0x400000000, 0x4210000000000000},
- {0x500000000, 0x4214000000000000},
- {0x800000000, 0x4220000000000000},
- {0x900000000, 0x4222000000000000},
- {0x273a798e187937a3, 0x43c39d3cc70c3c9c},
- {0xece3af835495a16b, 0x43ed9c75f06a92b4},
- {0xb668ecc11223344, 0x43a6cd1d98224467},
- {0x9e, 0x4063c00000000000},
- {0x43, 0x4050c00000000000},
- {0xaf73, 0x40e5ee6000000000},
- {0x116b, 0x40b16b0000000000},
- {0x658ecc, 0x415963b300000000},
- {0x2b3b4c, 0x41459da600000000},
- {0x88776655, 0x41e10eeccaa00000},
- {0x70000000, 0x41dc000000000000},
- {0x7200000, 0x419c800000000000},
- {0x7fffffff, 0x41dfffffffc00000},
- {0x56123761, 0x41d5848dd8400000},
- {0x7fffff00, 0x41dfffffc0000000},
- {0x761c4761eeeeeeee, 0x43dd8711d87bbbbc},
- {0x80000000eeeeeeee, 0x43e00000001dddde},
- {0x88888888dddddddd, 0x43e11111111bbbbc},
- {0xa0000000dddddddd, 0x43e40000001bbbbc},
- {0xddddddddaaaaaaaa, 0x43ebbbbbbbb55555},
- {0xe0000000aaaaaaaa, 0x43ec000000155555},
- {0xeeeeeeeeeeeeeeee, 0x43edddddddddddde},
- {0xfffffffdeeeeeeee, 0x43efffffffbdddde},
- {0xf0000000dddddddd, 0x43ee0000001bbbbc},
- {0x7fffffdddddddd, 0x435ffffff7777777},
- {0x3fffffaaaaaaaa, 0x434fffffd5555555},
- {0x1fffffaaaaaaaa, 0x433fffffaaaaaaaa},
- {0xfffff, 0x412ffffe00000000},
- {0x7ffff, 0x411ffffc00000000},
- {0x3ffff, 0x410ffff800000000},
- {0x1ffff, 0x40fffff000000000},
- {0xffff, 0x40efffe000000000},
- {0x7fff, 0x40dfffc000000000},
- {0x3fff, 0x40cfff8000000000},
- {0x1fff, 0x40bfff0000000000},
- {0xfff, 0x40affe0000000000},
- {0x7ff, 0x409ffc0000000000},
- {0x3ff, 0x408ff80000000000},
- {0x1ff, 0x407ff00000000000},
- {0x3fffffffffff, 0x42cfffffffffff80},
- {0x1fffffffffff, 0x42bfffffffffff00},
- {0xfffffffffff, 0x42affffffffffe00},
- {0x7ffffffffff, 0x429ffffffffffc00},
- {0x3ffffffffff, 0x428ffffffffff800},
- {0x1ffffffffff, 0x427ffffffffff000},
- {0x8000008000000000, 0x43e0000010000000},
- {0x8000008000000001, 0x43e0000010000000},
- {0x8000000000000400, 0x43e0000000000000},
- {0x8000000000000401, 0x43e0000000000001},
- {0x8000000000000402, 0x43e0000000000001},
- {0x8000000000000404, 0x43e0000000000001},
- {0x8000000000000408, 0x43e0000000000001},
- {0x8000000000000410, 0x43e0000000000001},
- {0x8000000000000420, 0x43e0000000000001},
- {0x8000000000000440, 0x43e0000000000001},
- {0x8000000000000480, 0x43e0000000000001},
- {0x8000000000000500, 0x43e0000000000001},
- {0x8000000000000600, 0x43e0000000000001}};
-
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref =
ExternalReference::wasm_uint64_to_float64(m.isolate());
-
- uint64_t input;
- double output;
-
- Node* function = m.ExternalConstant(ref);
- m.CallCFunction2(MachineType::Pointer(), MachineType::Pointer(),
- MachineType::Pointer(), function, m.PointerConstant(&input),
- m.PointerConstant(&output));
- m.Return(m.Int32Constant(4356));
-
- for (size_t i = 0; i < arraysize(values); i++) {
- input = values[i].input;
- m.Call();
- CHECK_EQ(values[i].expected, bit_cast<uint64_t>(output));
- }
+ TestExternalReference(&m, ref, wasm::uint64_to_float64_wrapper,
+ uint64_t(2124), 1.25);
}
TEST(RunCallFloat32ToInt64) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_float32_to_int64(m.isolate());
-
- float input;
- int64_t output;
-
- Node* function = m.ExternalConstant(ref);
- m.Return(m.CallCFunction2(
- MachineType::Int32(), MachineType::Pointer(), MachineType::Pointer(),
- function, m.PointerConstant(&input), m.PointerConstant(&output)));
- FOR_FLOAT32_INPUTS(i) {
- input = *i;
- if (*i >= static_cast<float>(std::numeric_limits<int64_t>::min()) &&
- *i < static_cast<float>(std::numeric_limits<int64_t>::max())) {
- CHECK_EQ(1, m.Call());
- CHECK_EQ(static_cast<int64_t>(*i), output);
- } else {
- CHECK_EQ(0, m.Call());
- }
- }
+ TestExternalReference(&m, ref, wasm::float32_to_int64_wrapper, 1.25f,
+ int64_t(2124));
}
TEST(RunCallFloat32ToUint64) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref =
ExternalReference::wasm_float32_to_uint64(m.isolate());
-
- float input;
- uint64_t output;
-
- Node* function = m.ExternalConstant(ref);
- m.Return(m.CallCFunction2(
- MachineType::Int32(), MachineType::Pointer(), MachineType::Pointer(),
- function, m.PointerConstant(&input), m.PointerConstant(&output)));
- FOR_FLOAT32_INPUTS(i) {
- input = *i;
- if (*i > -1.0 &&
- *i < static_cast<float>(std::numeric_limits<uint64_t>::max())) {
- CHECK_EQ(1, m.Call());
- CHECK_EQ(static_cast<uint64_t>(*i), output);
- } else {
- CHECK_EQ(0, m.Call());
- }
- }
+ TestExternalReference(&m, ref, wasm::float32_to_uint64_wrapper, 1.25f,
+ uint64_t(2124));
}
TEST(RunCallFloat64ToInt64) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_float64_to_int64(m.isolate());
-
- double input;
- int64_t output;
-
- Node* function = m.ExternalConstant(ref);
- m.Return(m.CallCFunction2(
- MachineType::Int32(), MachineType::Pointer(), MachineType::Pointer(),
- function, m.PointerConstant(&input), m.PointerConstant(&output)));
- FOR_FLOAT64_INPUTS(i) {
- input = *i;
- if (*i >= static_cast<double>(std::numeric_limits<int64_t>::min()) &&
- *i < static_cast<double>(std::numeric_limits<int64_t>::max())) {
- CHECK_EQ(1, m.Call());
- CHECK_EQ(static_cast<int64_t>(*i), output);
- } else {
- CHECK_EQ(0, m.Call());
- }
- }
+ TestExternalReference(&m, ref, wasm::float64_to_int64_wrapper, 1.25,
+ int64_t(2124));
}
TEST(RunCallFloat64ToUint64) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref =
ExternalReference::wasm_float64_to_uint64(m.isolate());
-
- double input;
- uint64_t output;
-
- Node* function = m.ExternalConstant(ref);
- m.Return(m.CallCFunction2(
- MachineType::Int32(), MachineType::Pointer(), MachineType::Pointer(),
- function, m.PointerConstant(&input), m.PointerConstant(&output)));
- FOR_FLOAT64_INPUTS(i) {
- input = *i;
- if (*i > -1.0 &&
- *i < static_cast<double>(std::numeric_limits<uint64_t>::max())) {
- CHECK_EQ(1, m.Call());
- CHECK_EQ(static_cast<uint64_t>(*i), output);
- } else {
- CHECK_EQ(0, m.Call());
- }
- }
+ TestExternalReference(&m, ref, wasm::float64_to_uint64_wrapper, 1.25,
+ uint64_t(2124));
}
TEST(RunCallInt64Div) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_int64_div(m.isolate());
-
- int64_t dst;
- int64_t src;
-
- Node* function = m.ExternalConstant(ref);
- m.Return(m.CallCFunction2(MachineType::Int32(), MachineType::Pointer(),
- MachineType::Pointer(), function,
- m.PointerConstant(&dst), m.PointerConstant(&src)));
- FOR_INT64_INPUTS(i) {
- FOR_INT64_INPUTS(j) {
- dst = *i;
- src = *j;
- if (src == 0) {
- CHECK_EQ(0, m.Call());
- } else if (src == -1 && dst == std::numeric_limits<int64_t>::min()) {
- CHECK_EQ(-1, m.Call());
- } else {
- CHECK_EQ(1, m.Call());
- CHECK_EQ(*i / *j, dst);
- }
- }
- }
+ TestExternalReference(&m, ref, wasm::int64_div_wrapper, int64_t(1774),
+ int64_t(21));
}
TEST(RunCallInt64Mod) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_int64_mod(m.isolate());
-
- int64_t dst;
- int64_t src;
-
- Node* function = m.ExternalConstant(ref);
- m.Return(m.CallCFunction2(MachineType::Int32(), MachineType::Pointer(),
- MachineType::Pointer(), function,
- m.PointerConstant(&dst), m.PointerConstant(&src)));
- FOR_INT64_INPUTS(i) {
- FOR_INT64_INPUTS(j) {
- dst = *i;
- src = *j;
- if (src == 0) {
- CHECK_EQ(0, m.Call());
- } else {
- CHECK_EQ(1, m.Call());
- CHECK_EQ(*i % *j, dst);
- }
- }
- }
+ TestExternalReference(&m, ref, wasm::int64_mod_wrapper, int64_t(1774),
+ int64_t(21));
}
TEST(RunCallUint64Div) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_uint64_div(m.isolate());
-
- uint64_t dst;
- uint64_t src;
-
- Node* function = m.ExternalConstant(ref);
- m.Return(m.CallCFunction2(MachineType::Int32(), MachineType::Pointer(),
- MachineType::Pointer(), function,
- m.PointerConstant(&dst), m.PointerConstant(&src)));
- FOR_UINT64_INPUTS(i) {
- FOR_UINT64_INPUTS(j) {
- dst = *i;
- src = *j;
- if (src == 0) {
- CHECK_EQ(0, m.Call());
- } else {
- CHECK_EQ(1, m.Call());
- CHECK_EQ(*i / *j, dst);
- }
- }
- }
+ TestExternalReference(&m, ref, wasm::uint64_div_wrapper, uint64_t(1774),
+ uint64_t(21));
}
TEST(RunCallUint64Mod) {
BufferedRawMachineAssemblerTester<int32_t> m;
ExternalReference ref = ExternalReference::wasm_uint64_mod(m.isolate());
+ TestExternalReference(&m, ref, wasm::uint64_mod_wrapper, uint64_t(1774),
+ uint64_t(21));
+}
- uint64_t dst;
- uint64_t src;
+TEST(RunCallWord32Ctz) {
+ BufferedRawMachineAssemblerTester<uint32_t> m;
+ ExternalReference ref = ExternalReference::wasm_word32_ctz(m.isolate());
+ TestExternalReference(&m, ref, wasm::word32_ctz_wrapper, uint32_t(1774));
+}
- Node* function = m.ExternalConstant(ref);
- m.Return(m.CallCFunction2(MachineType::Int32(), MachineType::Pointer(),
- MachineType::Pointer(), function,
- m.PointerConstant(&dst), m.PointerConstant(&src)));
- FOR_UINT64_INPUTS(i) {
- FOR_UINT64_INPUTS(j) {
- dst = *i;
- src = *j;
- if (src == 0) {
- CHECK_EQ(0, m.Call());
- } else {
- CHECK_EQ(1, m.Call());
- CHECK_EQ(*i % *j, dst);
- }
- }
- }
+TEST(RunCallWord64Ctz) {
+ BufferedRawMachineAssemblerTester<uint32_t> m;
+ ExternalReference ref = ExternalReference::wasm_word64_ctz(m.isolate());
+ TestExternalReference(&m, ref, wasm::word64_ctz_wrapper, uint64_t(1774));
+}
+
+TEST(RunCallWord32Popcnt) {
+ BufferedRawMachineAssemblerTester<uint32_t> m;
+ ExternalReference ref = ExternalReference::wasm_word32_popcnt(m.isolate());
+ TestExternalReference(&m, ref, wasm::word32_popcnt_wrapper, uint32_t(1774));
+}
+
+TEST(RunCallWord64Popcnt) {
+ BufferedRawMachineAssemblerTester<uint32_t> m;
+ ExternalReference ref = ExternalReference::wasm_word64_popcnt(m.isolate());
+ TestExternalReference(&m, ref, wasm::word64_popcnt_wrapper, uint64_t(1774));
}
} // namespace compiler
} // namespace internal
diff --git a/test/cctest/compiler/test-run-inlining.cc b/test/cctest/compiler/test-run-inlining.cc
index 234060c..e689bf7 100644
--- a/test/cctest/compiler/test-run-inlining.cc
+++ b/test/cctest/compiler/test-run-inlining.cc
@@ -16,9 +16,9 @@
void AssertInlineCount(const v8::FunctionCallbackInfo<v8::Value>& args) {
StackTraceFrameIterator it(CcTest::i_isolate());
int frames_seen = 0;
- JavaScriptFrame* topmost = it.frame();
+ JavaScriptFrame* topmost = it.javascript_frame();
while (!it.done()) {
- JavaScriptFrame* frame = it.frame();
+ JavaScriptFrame* frame = it.javascript_frame();
List<JSFunction*> functions(2);
frame->GetFunctions(&functions);
PrintF("%d %s, inline count: %d\n", frames_seen,
@@ -47,14 +47,11 @@
.FromJust());
}
-
const uint32_t kRestrictedInliningFlags =
- CompilationInfo::kFunctionContextSpecializing |
- CompilationInfo::kTypingEnabled;
+ CompilationInfo::kFunctionContextSpecializing;
const uint32_t kInlineFlags = CompilationInfo::kInliningEnabled |
- CompilationInfo::kFunctionContextSpecializing |
- CompilationInfo::kTypingEnabled;
+ CompilationInfo::kFunctionContextSpecializing;
} // namespace
diff --git a/test/cctest/compiler/test-run-jsops.cc b/test/cctest/compiler/test-run-jsops.cc
index b68fc1c..78e1257 100644
--- a/test/cctest/compiler/test-run-jsops.cc
+++ b/test/cctest/compiler/test-run-jsops.cc
@@ -512,7 +512,6 @@
TEST(ClassLiteral) {
- FLAG_harmony_sloppy = true;
const char* src =
"(function(a,b) {"
" class C {"
diff --git a/test/cctest/compiler/test-run-load-store.cc b/test/cctest/compiler/test-run-load-store.cc
new file mode 100644
index 0000000..6484d30
--- /dev/null
+++ b/test/cctest/compiler/test-run-load-store.cc
@@ -0,0 +1,919 @@
+// Copyright 2016 the V8 project authors. All rights reserved. Use of this
+// source code is governed by a BSD-style license that can be found in the
+// LICENSE file.
+
+#include <cmath>
+#include <functional>
+#include <limits>
+
+#include "src/base/bits.h"
+#include "src/base/utils/random-number-generator.h"
+#include "src/codegen.h"
+#include "test/cctest/cctest.h"
+#include "test/cctest/compiler/codegen-tester.h"
+#include "test/cctest/compiler/graph-builder-tester.h"
+#include "test/cctest/compiler/value-helper.h"
+
+using namespace v8::base;
+
+namespace {
+template <typename Type>
+void CheckOobValue(Type val) {
+ UNREACHABLE();
+}
+
+template <>
+void CheckOobValue(int32_t val) {
+ CHECK_EQ(0, val);
+}
+
+template <>
+void CheckOobValue(int64_t val) {
+ CHECK_EQ(0, val);
+}
+
+template <>
+void CheckOobValue(float val) {
+ CHECK(std::isnan(val));
+}
+
+template <>
+void CheckOobValue(double val) {
+ CHECK(std::isnan(val));
+}
+} // namespace
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+// This is a America!
+#define A_BILLION 1000000000ULL
+#define A_GIG (1024ULL * 1024ULL * 1024ULL)
+
+TEST(RunLoadInt32) {
+ RawMachineAssemblerTester<int32_t> m;
+
+ int32_t p1 = 0; // loads directly from this location.
+ m.Return(m.LoadFromPointer(&p1, MachineType::Int32()));
+
+ FOR_INT32_INPUTS(i) {
+ p1 = *i;
+ CHECK_EQ(p1, m.Call());
+ }
+}
+
+TEST(RunLoadInt32Offset) {
+ int32_t p1 = 0; // loads directly from this location.
+
+ int32_t offsets[] = {-2000000, -100, -101, 1, 3,
+ 7, 120, 2000, 2000000000, 0xff};
+
+ for (size_t i = 0; i < arraysize(offsets); i++) {
+ RawMachineAssemblerTester<int32_t> m;
+ int32_t offset = offsets[i];
+ byte* pointer = reinterpret_cast<byte*>(&p1) - offset;
+ // generate load [#base + #index]
+ m.Return(m.LoadFromPointer(pointer, MachineType::Int32(), offset));
+
+ FOR_INT32_INPUTS(j) {
+ p1 = *j;
+ CHECK_EQ(p1, m.Call());
+ }
+ }
+}
+
+TEST(RunLoadStoreFloat32Offset) {
+ float p1 = 0.0f; // loads directly from this location.
+ float p2 = 0.0f; // and stores directly into this location.
+
+ FOR_INT32_INPUTS(i) {
+ int32_t magic = 0x2342aabb + *i * 3;
+ RawMachineAssemblerTester<int32_t> m;
+ int32_t offset = *i;
+ byte* from = reinterpret_cast<byte*>(&p1) - offset;
+ byte* to = reinterpret_cast<byte*>(&p2) - offset;
+ // generate load [#base + #index]
+ Node* load = m.Load(MachineType::Float32(), m.PointerConstant(from),
+ m.IntPtrConstant(offset));
+ m.Store(MachineRepresentation::kFloat32, m.PointerConstant(to),
+ m.IntPtrConstant(offset), load, kNoWriteBarrier);
+ m.Return(m.Int32Constant(magic));
+
+ FOR_FLOAT32_INPUTS(j) {
+ p1 = *j;
+ p2 = *j - 5;
+ CHECK_EQ(magic, m.Call());
+ CheckDoubleEq(p1, p2);
+ }
+ }
+}
+
+TEST(RunLoadStoreFloat64Offset) {
+ double p1 = 0; // loads directly from this location.
+ double p2 = 0; // and stores directly into this location.
+
+ FOR_INT32_INPUTS(i) {
+ int32_t magic = 0x2342aabb + *i * 3;
+ RawMachineAssemblerTester<int32_t> m;
+ int32_t offset = *i;
+ byte* from = reinterpret_cast<byte*>(&p1) - offset;
+ byte* to = reinterpret_cast<byte*>(&p2) - offset;
+ // generate load [#base + #index]
+ Node* load = m.Load(MachineType::Float64(), m.PointerConstant(from),
+ m.IntPtrConstant(offset));
+ m.Store(MachineRepresentation::kFloat64, m.PointerConstant(to),
+ m.IntPtrConstant(offset), load, kNoWriteBarrier);
+ m.Return(m.Int32Constant(magic));
+
+ FOR_FLOAT64_INPUTS(j) {
+ p1 = *j;
+ p2 = *j - 5;
+ CHECK_EQ(magic, m.Call());
+ CheckDoubleEq(p1, p2);
+ }
+ }
+}
+
+namespace {
+template <typename Type>
+void RunLoadImmIndex(MachineType rep) {
+ const int kNumElems = 3;
+ Type buffer[kNumElems];
+
+ // initialize the buffer with some raw data.
+ byte* raw = reinterpret_cast<byte*>(buffer);
+ for (size_t i = 0; i < sizeof(buffer); i++) {
+ raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
+ }
+
+ // Test with various large and small offsets.
+ for (int offset = -1; offset <= 200000; offset *= -5) {
+ for (int i = 0; i < kNumElems; i++) {
+ BufferedRawMachineAssemblerTester<Type> m;
+ Node* base = m.PointerConstant(buffer - offset);
+ Node* index = m.Int32Constant((offset + i) * sizeof(buffer[0]));
+ m.Return(m.Load(rep, base, index));
+
+ volatile Type expected = buffer[i];
+ volatile Type actual = m.Call();
+ CHECK_EQ(expected, actual);
+ }
+ }
+}
+
+template <typename CType>
+void RunLoadStore(MachineType rep) {
+ const int kNumElems = 4;
+ CType buffer[kNumElems];
+
+ for (int32_t x = 0; x < kNumElems; x++) {
+ int32_t y = kNumElems - x - 1;
+ // initialize the buffer with raw data.
+ byte* raw = reinterpret_cast<byte*>(buffer);
+ for (size_t i = 0; i < sizeof(buffer); i++) {
+ raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
+ }
+
+ RawMachineAssemblerTester<int32_t> m;
+ int32_t OK = 0x29000 + x;
+ Node* base = m.PointerConstant(buffer);
+ Node* index0 = m.IntPtrConstant(x * sizeof(buffer[0]));
+ Node* load = m.Load(rep, base, index0);
+ Node* index1 = m.IntPtrConstant(y * sizeof(buffer[0]));
+ m.Store(rep.representation(), base, index1, load, kNoWriteBarrier);
+ m.Return(m.Int32Constant(OK));
+
+ CHECK(buffer[x] != buffer[y]);
+ CHECK_EQ(OK, m.Call());
+ CHECK(buffer[x] == buffer[y]);
+ }
+}
+} // namespace
+
+TEST(RunLoadImmIndex) {
+ RunLoadImmIndex<int8_t>(MachineType::Int8());
+ RunLoadImmIndex<uint8_t>(MachineType::Uint8());
+ RunLoadImmIndex<int16_t>(MachineType::Int16());
+ RunLoadImmIndex<uint16_t>(MachineType::Uint16());
+ RunLoadImmIndex<int32_t>(MachineType::Int32());
+ RunLoadImmIndex<uint32_t>(MachineType::Uint32());
+ RunLoadImmIndex<int32_t*>(MachineType::AnyTagged());
+ RunLoadImmIndex<float>(MachineType::Float32());
+ RunLoadImmIndex<double>(MachineType::Float64());
+#if V8_TARGET_ARCH_64_BIT
+ RunLoadImmIndex<int64_t>(MachineType::Int64());
+#endif
+ // TODO(titzer): test various indexing modes.
+}
+
+TEST(RunLoadStore) {
+ RunLoadStore<int8_t>(MachineType::Int8());
+ RunLoadStore<uint8_t>(MachineType::Uint8());
+ RunLoadStore<int16_t>(MachineType::Int16());
+ RunLoadStore<uint16_t>(MachineType::Uint16());
+ RunLoadStore<int32_t>(MachineType::Int32());
+ RunLoadStore<uint32_t>(MachineType::Uint32());
+ RunLoadStore<void*>(MachineType::AnyTagged());
+ RunLoadStore<float>(MachineType::Float32());
+ RunLoadStore<double>(MachineType::Float64());
+#if V8_TARGET_ARCH_64_BIT
+ RunLoadStore<int64_t>(MachineType::Int64());
+#endif
+}
+
+#if V8_TARGET_LITTLE_ENDIAN
+#define LSB(addr, bytes) addr
+#elif V8_TARGET_BIG_ENDIAN
+#define LSB(addr, bytes) reinterpret_cast<byte*>(addr + 1) - bytes
+#else
+#error "Unknown Architecture"
+#endif
+
+TEST(RunLoadStoreSignExtend32) {
+ int32_t buffer[4];
+ RawMachineAssemblerTester<int32_t> m;
+ Node* load8 = m.LoadFromPointer(LSB(&buffer[0], 1), MachineType::Int8());
+ Node* load16 = m.LoadFromPointer(LSB(&buffer[0], 2), MachineType::Int16());
+ Node* load32 = m.LoadFromPointer(&buffer[0], MachineType::Int32());
+ m.StoreToPointer(&buffer[1], MachineRepresentation::kWord32, load8);
+ m.StoreToPointer(&buffer[2], MachineRepresentation::kWord32, load16);
+ m.StoreToPointer(&buffer[3], MachineRepresentation::kWord32, load32);
+ m.Return(load8);
+
+ FOR_INT32_INPUTS(i) {
+ buffer[0] = *i;
+
+ CHECK_EQ(static_cast<int8_t>(*i & 0xff), m.Call());
+ CHECK_EQ(static_cast<int8_t>(*i & 0xff), buffer[1]);
+ CHECK_EQ(static_cast<int16_t>(*i & 0xffff), buffer[2]);
+ CHECK_EQ(*i, buffer[3]);
+ }
+}
+
+TEST(RunLoadStoreZeroExtend32) {
+ uint32_t buffer[4];
+ RawMachineAssemblerTester<uint32_t> m;
+ Node* load8 = m.LoadFromPointer(LSB(&buffer[0], 1), MachineType::Uint8());
+ Node* load16 = m.LoadFromPointer(LSB(&buffer[0], 2), MachineType::Uint16());
+ Node* load32 = m.LoadFromPointer(&buffer[0], MachineType::Uint32());
+ m.StoreToPointer(&buffer[1], MachineRepresentation::kWord32, load8);
+ m.StoreToPointer(&buffer[2], MachineRepresentation::kWord32, load16);
+ m.StoreToPointer(&buffer[3], MachineRepresentation::kWord32, load32);
+ m.Return(load8);
+
+ FOR_UINT32_INPUTS(i) {
+ buffer[0] = *i;
+
+ CHECK_EQ((*i & 0xff), m.Call());
+ CHECK_EQ((*i & 0xff), buffer[1]);
+ CHECK_EQ((*i & 0xffff), buffer[2]);
+ CHECK_EQ(*i, buffer[3]);
+ }
+}
+
+#if V8_TARGET_ARCH_64_BIT
+TEST(RunCheckedLoadInt64) {
+ int64_t buffer[] = {0x66bbccddeeff0011LL, 0x1122334455667788LL};
+ RawMachineAssemblerTester<int64_t> m(MachineType::Int32());
+ Node* base = m.PointerConstant(buffer);
+ Node* index = m.Parameter(0);
+ Node* length = m.Int32Constant(16);
+ Node* load = m.AddNode(m.machine()->CheckedLoad(MachineType::Int64()), base,
+ index, length);
+ m.Return(load);
+
+ CHECK_EQ(buffer[0], m.Call(0));
+ CHECK_EQ(buffer[1], m.Call(8));
+ CheckOobValue(m.Call(16));
+}
+
+TEST(RunLoadStoreSignExtend64) {
+ if (true) return; // TODO(titzer): sign extension of loads to 64-bit.
+ int64_t buffer[5];
+ RawMachineAssemblerTester<int64_t> m;
+ Node* load8 = m.LoadFromPointer(LSB(&buffer[0], 1), MachineType::Int8());
+ Node* load16 = m.LoadFromPointer(LSB(&buffer[0], 2), MachineType::Int16());
+ Node* load32 = m.LoadFromPointer(LSB(&buffer[0], 4), MachineType::Int32());
+ Node* load64 = m.LoadFromPointer(&buffer[0], MachineType::Int64());
+ m.StoreToPointer(&buffer[1], MachineRepresentation::kWord64, load8);
+ m.StoreToPointer(&buffer[2], MachineRepresentation::kWord64, load16);
+ m.StoreToPointer(&buffer[3], MachineRepresentation::kWord64, load32);
+ m.StoreToPointer(&buffer[4], MachineRepresentation::kWord64, load64);
+ m.Return(load8);
+
+ FOR_INT64_INPUTS(i) {
+ buffer[0] = *i;
+
+ CHECK_EQ(static_cast<int8_t>(*i & 0xff), m.Call());
+ CHECK_EQ(static_cast<int8_t>(*i & 0xff), buffer[1]);
+ CHECK_EQ(static_cast<int16_t>(*i & 0xffff), buffer[2]);
+ CHECK_EQ(static_cast<int32_t>(*i & 0xffffffff), buffer[3]);
+ CHECK_EQ(*i, buffer[4]);
+ }
+}
+
+TEST(RunLoadStoreZeroExtend64) {
+ if (kPointerSize < 8) return;
+ uint64_t buffer[5];
+ RawMachineAssemblerTester<int64_t> m;
+ Node* load8 = m.LoadFromPointer(LSB(&buffer[0], 1), MachineType::Uint8());
+ Node* load16 = m.LoadFromPointer(LSB(&buffer[0], 2), MachineType::Uint16());
+ Node* load32 = m.LoadFromPointer(LSB(&buffer[0], 4), MachineType::Uint32());
+ Node* load64 = m.LoadFromPointer(&buffer[0], MachineType::Uint64());
+ m.StoreToPointer(&buffer[1], MachineRepresentation::kWord64, load8);
+ m.StoreToPointer(&buffer[2], MachineRepresentation::kWord64, load16);
+ m.StoreToPointer(&buffer[3], MachineRepresentation::kWord64, load32);
+ m.StoreToPointer(&buffer[4], MachineRepresentation::kWord64, load64);
+ m.Return(load8);
+
+ FOR_UINT64_INPUTS(i) {
+ buffer[0] = *i;
+
+ CHECK_EQ((*i & 0xff), m.Call());
+ CHECK_EQ((*i & 0xff), buffer[1]);
+ CHECK_EQ((*i & 0xffff), buffer[2]);
+ CHECK_EQ((*i & 0xffffffff), buffer[3]);
+ CHECK_EQ(*i, buffer[4]);
+ }
+}
+
+TEST(RunCheckedStoreInt64) {
+ const int64_t write = 0x5566778899aabbLL;
+ const int64_t before = 0x33bbccddeeff0011LL;
+ int64_t buffer[] = {before, before};
+ RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
+ Node* base = m.PointerConstant(buffer);
+ Node* index = m.Parameter(0);
+ Node* length = m.Int32Constant(16);
+ Node* value = m.Int64Constant(write);
+ Node* store =
+ m.AddNode(m.machine()->CheckedStore(MachineRepresentation::kWord64), base,
+ index, length, value);
+ USE(store);
+ m.Return(m.Int32Constant(11));
+
+ CHECK_EQ(11, m.Call(16));
+ CHECK_EQ(before, buffer[0]);
+ CHECK_EQ(before, buffer[1]);
+
+ CHECK_EQ(11, m.Call(0));
+ CHECK_EQ(write, buffer[0]);
+ CHECK_EQ(before, buffer[1]);
+
+ CHECK_EQ(11, m.Call(8));
+ CHECK_EQ(write, buffer[0]);
+ CHECK_EQ(write, buffer[1]);
+}
+#endif
+
+namespace {
+template <typename IntType>
+void LoadStoreTruncation(MachineType kRepresentation) {
+ IntType input;
+
+ RawMachineAssemblerTester<int32_t> m;
+ Node* a = m.LoadFromPointer(&input, kRepresentation);
+ Node* ap1 = m.Int32Add(a, m.Int32Constant(1));
+ m.StoreToPointer(&input, kRepresentation.representation(), ap1);
+ m.Return(ap1);
+
+ const IntType max = std::numeric_limits<IntType>::max();
+ const IntType min = std::numeric_limits<IntType>::min();
+
+ // Test upper bound.
+ input = max;
+ CHECK_EQ(max + 1, m.Call());
+ CHECK_EQ(min, input);
+
+ // Test lower bound.
+ input = min;
+ CHECK_EQ(static_cast<IntType>(max + 2), m.Call());
+ CHECK_EQ(min + 1, input);
+
+ // Test all one byte values that are not one byte bounds.
+ for (int i = -127; i < 127; i++) {
+ input = i;
+ int expected = i >= 0 ? i + 1 : max + (i - min) + 2;
+ CHECK_EQ(static_cast<IntType>(expected), m.Call());
+ CHECK_EQ(static_cast<IntType>(i + 1), input);
+ }
+}
+} // namespace
+
+TEST(RunLoadStoreTruncation) {
+ LoadStoreTruncation<int8_t>(MachineType::Int8());
+ LoadStoreTruncation<int16_t>(MachineType::Int16());
+}
+
+void TestRunOobCheckedLoad(bool length_is_immediate) {
+ USE(CheckOobValue<int32_t>);
+ USE(CheckOobValue<int64_t>);
+ USE(CheckOobValue<float>);
+ USE(CheckOobValue<double>);
+
+ RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+ MachineType::Int32());
+ MachineOperatorBuilder machine(m.zone());
+ const int32_t kNumElems = 27;
+ const int32_t kLength = kNumElems * 4;
+
+ int32_t buffer[kNumElems];
+ Node* base = m.PointerConstant(buffer);
+ Node* offset = m.Parameter(0);
+ Node* len = length_is_immediate ? m.Int32Constant(kLength) : m.Parameter(1);
+ Node* node =
+ m.AddNode(machine.CheckedLoad(MachineType::Int32()), base, offset, len);
+ m.Return(node);
+
+ {
+ // randomize memory.
+ v8::base::RandomNumberGenerator rng;
+ rng.SetSeed(100);
+ rng.NextBytes(&buffer[0], sizeof(buffer));
+ }
+
+ // in-bounds accesses.
+ for (int32_t i = 0; i < kNumElems; i++) {
+ int32_t offset = static_cast<int32_t>(i * sizeof(int32_t));
+ int32_t expected = buffer[i];
+ CHECK_EQ(expected, m.Call(offset, kLength));
+ }
+
+ // slightly out-of-bounds accesses.
+ for (int32_t i = kLength; i < kNumElems + 30; i++) {
+ int32_t offset = static_cast<int32_t>(i * sizeof(int32_t));
+ CheckOobValue(m.Call(offset, kLength));
+ }
+
+ // way out-of-bounds accesses.
+ for (int32_t offset = -2000000000; offset <= 2000000000;
+ offset += 100000000) {
+ if (offset == 0) continue;
+ CheckOobValue(m.Call(offset, kLength));
+ }
+}
+
+TEST(RunOobCheckedLoad) { TestRunOobCheckedLoad(false); }
+
+TEST(RunOobCheckedLoadImm) { TestRunOobCheckedLoad(true); }
+
+void TestRunOobCheckedStore(bool length_is_immediate) {
+ RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+ MachineType::Int32());
+ MachineOperatorBuilder machine(m.zone());
+ const int32_t kNumElems = 29;
+ const int32_t kValue = -78227234;
+ const int32_t kLength = kNumElems * 4;
+
+ int32_t buffer[kNumElems + kNumElems];
+ Node* base = m.PointerConstant(buffer);
+ Node* offset = m.Parameter(0);
+ Node* len = length_is_immediate ? m.Int32Constant(kLength) : m.Parameter(1);
+ Node* val = m.Int32Constant(kValue);
+ m.AddNode(machine.CheckedStore(MachineRepresentation::kWord32), base, offset,
+ len, val);
+ m.Return(val);
+
+ // in-bounds accesses.
+ for (int32_t i = 0; i < kNumElems; i++) {
+ memset(buffer, 0, sizeof(buffer));
+ int32_t offset = static_cast<int32_t>(i * sizeof(int32_t));
+ CHECK_EQ(kValue, m.Call(offset, kLength));
+ for (int32_t j = 0; j < kNumElems + kNumElems; j++) {
+ if (i == j) {
+ CHECK_EQ(kValue, buffer[j]);
+ } else {
+ CHECK_EQ(0, buffer[j]);
+ }
+ }
+ }
+
+ memset(buffer, 0, sizeof(buffer));
+
+ // slightly out-of-bounds accesses.
+ for (int32_t i = kLength; i < kNumElems + 30; i++) {
+ int32_t offset = static_cast<int32_t>(i * sizeof(int32_t));
+ CHECK_EQ(kValue, m.Call(offset, kLength));
+ for (int32_t j = 0; j < kNumElems + kNumElems; j++) {
+ CHECK_EQ(0, buffer[j]);
+ }
+ }
+
+ // way out-of-bounds accesses.
+ for (int32_t offset = -2000000000; offset <= 2000000000;
+ offset += 100000000) {
+ if (offset == 0) continue;
+ CHECK_EQ(kValue, m.Call(offset, kLength));
+ for (int32_t j = 0; j < kNumElems + kNumElems; j++) {
+ CHECK_EQ(0, buffer[j]);
+ }
+ }
+}
+
+TEST(RunOobCheckedStore) { TestRunOobCheckedStore(false); }
+
+TEST(RunOobCheckedStoreImm) { TestRunOobCheckedStore(true); }
+
+// TODO(titzer): CheckedLoad/CheckedStore don't support 64-bit offsets.
+#define ALLOW_64_BIT_OFFSETS 0
+
+#if V8_TARGET_ARCH_64_BIT && ALLOW_64_BIT_OFFSETS
+
+void TestRunOobCheckedLoad64(uint32_t pseudo_base, bool length_is_immediate) {
+ RawMachineAssemblerTester<int32_t> m(MachineType::Uint64(),
+ MachineType::Uint64());
+ MachineOperatorBuilder machine(m.zone());
+ const uint32_t kNumElems = 25;
+ const uint32_t kLength = kNumElems * 4;
+ int32_t real_buffer[kNumElems];
+
+ // Simulate the end of a large buffer.
+ int32_t* buffer = real_buffer - (pseudo_base / 4);
+ uint64_t length = kLength + pseudo_base;
+
+ Node* base = m.PointerConstant(buffer);
+ Node* offset = m.Parameter(0);
+ Node* len = length_is_immediate ? m.Int64Constant(length) : m.Parameter(1);
+ Node* node =
+ m.AddNode(machine.CheckedLoad(MachineType::Int32()), base, offset, len);
+ m.Return(node);
+
+ {
+ // randomize memory.
+ v8::base::RandomNumberGenerator rng;
+ rng.SetSeed(100);
+ rng.NextBytes(&real_buffer[0], sizeof(real_buffer));
+ }
+
+ // in-bounds accesses.
+ for (uint32_t i = 0; i < kNumElems; i++) {
+ uint64_t offset = pseudo_base + i * 4;
+ int32_t expected = real_buffer[i];
+ CHECK_EQ(expected, m.Call(offset, length));
+ }
+
+ // in-bounds accesses w.r.t lower 32-bits, but upper bits set.
+ for (uint64_t i = 0x100000000ULL; i != 0; i <<= 1) {
+ uint64_t offset = pseudo_base + i;
+ CheckOobValue(m.Call(offset, length));
+ }
+
+ // slightly out-of-bounds accesses.
+ for (uint32_t i = kLength; i < kNumElems + 30; i++) {
+ uint64_t offset = pseudo_base + i * 4;
+ CheckOobValue(0, m.Call(offset, length));
+ }
+
+ // way out-of-bounds accesses.
+ for (uint64_t offset = length; offset < 100 * A_BILLION; offset += A_GIG) {
+ if (offset < length) continue;
+ CheckOobValue(0, m.Call(offset, length));
+ }
+}
+
+TEST(RunOobCheckedLoad64_0) {
+ TestRunOobCheckedLoad64(0, false);
+ TestRunOobCheckedLoad64(0, true);
+}
+
+TEST(RunOobCheckedLoad64_1) {
+ TestRunOobCheckedLoad64(1 * A_BILLION, false);
+ TestRunOobCheckedLoad64(1 * A_BILLION, true);
+}
+
+TEST(RunOobCheckedLoad64_2) {
+ TestRunOobCheckedLoad64(2 * A_BILLION, false);
+ TestRunOobCheckedLoad64(2 * A_BILLION, true);
+}
+
+TEST(RunOobCheckedLoad64_3) {
+ TestRunOobCheckedLoad64(3 * A_BILLION, false);
+ TestRunOobCheckedLoad64(3 * A_BILLION, true);
+}
+
+TEST(RunOobCheckedLoad64_4) {
+ TestRunOobCheckedLoad64(4 * A_BILLION, false);
+ TestRunOobCheckedLoad64(4 * A_BILLION, true);
+}
+
+void TestRunOobCheckedStore64(uint32_t pseudo_base, bool length_is_immediate) {
+ RawMachineAssemblerTester<int32_t> m(MachineType::Uint64(),
+ MachineType::Uint64());
+ MachineOperatorBuilder machine(m.zone());
+ const uint32_t kNumElems = 21;
+ const uint32_t kLength = kNumElems * 4;
+ const uint32_t kValue = 897234987;
+ int32_t real_buffer[kNumElems + kNumElems];
+
+ // Simulate the end of a large buffer.
+ int32_t* buffer = real_buffer - (pseudo_base / 4);
+ uint64_t length = kLength + pseudo_base;
+
+ Node* base = m.PointerConstant(buffer);
+ Node* offset = m.Parameter(0);
+ Node* len = length_is_immediate ? m.Int64Constant(length) : m.Parameter(1);
+ Node* val = m.Int32Constant(kValue);
+ m.AddNode(machine.CheckedStore(MachineRepresentation::kWord32), base, offset,
+ len, val);
+ m.Return(val);
+
+ // in-bounds accesses.
+ for (uint32_t i = 0; i < kNumElems; i++) {
+ memset(real_buffer, 0, sizeof(real_buffer));
+ uint64_t offset = pseudo_base + i * 4;
+ CHECK_EQ(kValue, m.Call(offset, length));
+ for (uint32_t j = 0; j < kNumElems + kNumElems; j++) {
+ if (i == j) {
+ CHECK_EQ(kValue, real_buffer[j]);
+ } else {
+ CHECK_EQ(0, real_buffer[j]);
+ }
+ }
+ }
+
+ memset(real_buffer, 0, sizeof(real_buffer));
+
+ // in-bounds accesses w.r.t lower 32-bits, but upper bits set.
+ for (uint64_t i = 0x100000000ULL; i != 0; i <<= 1) {
+ uint64_t offset = pseudo_base + i;
+ CHECK_EQ(kValue, m.Call(offset, length));
+ for (int32_t j = 0; j < kNumElems + kNumElems; j++) {
+ CHECK_EQ(0, real_buffer[j]);
+ }
+ }
+
+ // slightly out-of-bounds accesses.
+ for (uint32_t i = kLength; i < kNumElems + 30; i++) {
+ uint64_t offset = pseudo_base + i * 4;
+ CHECK_EQ(kValue, m.Call(offset, length));
+ for (int32_t j = 0; j < kNumElems + kNumElems; j++) {
+ CHECK_EQ(0, real_buffer[j]);
+ }
+ }
+
+ // way out-of-bounds accesses.
+ for (uint64_t offset = length; offset < 100 * A_BILLION; offset += A_GIG) {
+ if (offset < length) continue;
+ CHECK_EQ(kValue, m.Call(offset, length));
+ for (int32_t j = 0; j < kNumElems + kNumElems; j++) {
+ CHECK_EQ(0, real_buffer[j]);
+ }
+ }
+}
+
+TEST(RunOobCheckedStore64_0) {
+ TestRunOobCheckedStore64(0, false);
+ TestRunOobCheckedStore64(0, true);
+}
+
+TEST(RunOobCheckedStore64_1) {
+ TestRunOobCheckedStore64(1 * A_BILLION, false);
+ TestRunOobCheckedStore64(1 * A_BILLION, true);
+}
+
+TEST(RunOobCheckedStore64_2) {
+ TestRunOobCheckedStore64(2 * A_BILLION, false);
+ TestRunOobCheckedStore64(2 * A_BILLION, true);
+}
+
+TEST(RunOobCheckedStore64_3) {
+ TestRunOobCheckedStore64(3 * A_BILLION, false);
+ TestRunOobCheckedStore64(3 * A_BILLION, true);
+}
+
+TEST(RunOobCheckedStore64_4) {
+ TestRunOobCheckedStore64(4 * A_BILLION, false);
+ TestRunOobCheckedStore64(4 * A_BILLION, true);
+}
+
+#endif
+
+void TestRunOobCheckedLoad_pseudo(uint64_t x, bool length_is_immediate) {
+ RawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
+ MachineType::Uint32());
+
+ uint32_t pseudo_base = static_cast<uint32_t>(x);
+ MachineOperatorBuilder machine(m.zone());
+ const uint32_t kNumElems = 29;
+ const uint32_t kLength = pseudo_base + kNumElems * 4;
+
+ int32_t buffer[kNumElems];
+ Node* base = m.PointerConstant(reinterpret_cast<byte*>(buffer) - pseudo_base);
+ Node* offset = m.Parameter(0);
+ Node* len = length_is_immediate ? m.Int32Constant(kLength) : m.Parameter(1);
+ Node* node =
+ m.AddNode(machine.CheckedLoad(MachineType::Int32()), base, offset, len);
+ m.Return(node);
+
+ {
+ // randomize memory.
+ v8::base::RandomNumberGenerator rng;
+ rng.SetSeed(100);
+ rng.NextBytes(&buffer[0], sizeof(buffer));
+ }
+
+ // in-bounds accesses.
+ for (uint32_t i = 0; i < kNumElems; i++) {
+ uint32_t offset = static_cast<uint32_t>(i * sizeof(int32_t));
+ uint32_t expected = buffer[i];
+ CHECK_EQ(expected, m.Call(offset + pseudo_base, kLength));
+ }
+
+ // slightly out-of-bounds accesses.
+ for (int32_t i = kNumElems; i < kNumElems + 30; i++) {
+ uint32_t offset = static_cast<uint32_t>(i * sizeof(int32_t));
+ CheckOobValue(m.Call(offset + pseudo_base, kLength));
+ }
+
+ // way out-of-bounds accesses.
+ for (uint64_t i = pseudo_base + sizeof(buffer); i < 0xFFFFFFFF;
+ i += A_BILLION) {
+ uint32_t offset = static_cast<uint32_t>(i);
+ CheckOobValue(m.Call(offset, kLength));
+ }
+}
+
+TEST(RunOobCheckedLoad_pseudo0) {
+ TestRunOobCheckedLoad_pseudo(0, false);
+ TestRunOobCheckedLoad_pseudo(0, true);
+}
+
+TEST(RunOobCheckedLoad_pseudo1) {
+ TestRunOobCheckedLoad_pseudo(100000, false);
+ TestRunOobCheckedLoad_pseudo(100000, true);
+}
+
+TEST(RunOobCheckedLoad_pseudo2) {
+ TestRunOobCheckedLoad_pseudo(A_BILLION, false);
+ TestRunOobCheckedLoad_pseudo(A_BILLION, true);
+}
+
+TEST(RunOobCheckedLoad_pseudo3) {
+ TestRunOobCheckedLoad_pseudo(A_GIG, false);
+ TestRunOobCheckedLoad_pseudo(A_GIG, true);
+}
+
+TEST(RunOobCheckedLoad_pseudo4) {
+ TestRunOobCheckedLoad_pseudo(2 * A_BILLION, false);
+ TestRunOobCheckedLoad_pseudo(2 * A_BILLION, true);
+}
+
+TEST(RunOobCheckedLoad_pseudo5) {
+ TestRunOobCheckedLoad_pseudo(2 * A_GIG, false);
+ TestRunOobCheckedLoad_pseudo(2 * A_GIG, true);
+}
+
+TEST(RunOobCheckedLoad_pseudo6) {
+ TestRunOobCheckedLoad_pseudo(3 * A_BILLION, false);
+ TestRunOobCheckedLoad_pseudo(3 * A_BILLION, true);
+}
+
+TEST(RunOobCheckedLoad_pseudo7) {
+ TestRunOobCheckedLoad_pseudo(3 * A_GIG, false);
+ TestRunOobCheckedLoad_pseudo(3 * A_GIG, true);
+}
+
+TEST(RunOobCheckedLoad_pseudo8) {
+ TestRunOobCheckedLoad_pseudo(4 * A_BILLION, false);
+ TestRunOobCheckedLoad_pseudo(4 * A_BILLION, true);
+}
+
+template <typename MemType>
+void TestRunOobCheckedLoadT_pseudo(uint64_t x, bool length_is_immediate) {
+ const int32_t kReturn = 11999;
+ const uint32_t kNumElems = 29;
+ MemType buffer[kNumElems];
+ uint32_t pseudo_base = static_cast<uint32_t>(x);
+ const uint32_t kLength = static_cast<uint32_t>(pseudo_base + sizeof(buffer));
+
+ MemType result;
+
+ RawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
+ MachineType::Uint32());
+ MachineOperatorBuilder machine(m.zone());
+ Node* base = m.PointerConstant(reinterpret_cast<byte*>(buffer) - pseudo_base);
+ Node* offset = m.Parameter(0);
+ Node* len = length_is_immediate ? m.Int32Constant(kLength) : m.Parameter(1);
+ Node* node = m.AddNode(machine.CheckedLoad(MachineTypeForC<MemType>()), base,
+ offset, len);
+ Node* store = m.StoreToPointer(
+ &result, MachineTypeForC<MemType>().representation(), node);
+ USE(store);
+ m.Return(m.Int32Constant(kReturn));
+
+ {
+ // randomize memory.
+ v8::base::RandomNumberGenerator rng;
+ rng.SetSeed(103);
+ rng.NextBytes(&buffer[0], sizeof(buffer));
+ }
+
+ // in-bounds accesses.
+ for (uint32_t i = 0; i < kNumElems; i++) {
+ uint32_t offset = static_cast<uint32_t>(i * sizeof(MemType));
+ MemType expected = buffer[i];
+ CHECK_EQ(kReturn, m.Call(offset + pseudo_base, kLength));
+ CHECK_EQ(expected, result);
+ }
+
+ // slightly out-of-bounds accesses.
+ for (int32_t i = kNumElems; i < kNumElems + 30; i++) {
+ uint32_t offset = static_cast<uint32_t>(i * sizeof(MemType));
+ CHECK_EQ(kReturn, m.Call(offset + pseudo_base, kLength));
+ CheckOobValue(result);
+ }
+
+ // way out-of-bounds accesses.
+ for (uint64_t i = pseudo_base + sizeof(buffer); i < 0xFFFFFFFF;
+ i += A_BILLION) {
+ uint32_t offset = static_cast<uint32_t>(i);
+ CHECK_EQ(kReturn, m.Call(offset, kLength));
+ CheckOobValue(result);
+ }
+}
+
+TEST(RunOobCheckedLoadT_pseudo0) {
+ TestRunOobCheckedLoadT_pseudo<int32_t>(0, false);
+ TestRunOobCheckedLoadT_pseudo<int32_t>(0, true);
+ TestRunOobCheckedLoadT_pseudo<float>(0, false);
+ TestRunOobCheckedLoadT_pseudo<float>(0, true);
+ TestRunOobCheckedLoadT_pseudo<double>(0, false);
+ TestRunOobCheckedLoadT_pseudo<double>(0, true);
+}
+
+TEST(RunOobCheckedLoadT_pseudo1) {
+ TestRunOobCheckedLoadT_pseudo<int32_t>(100000, false);
+ TestRunOobCheckedLoadT_pseudo<int32_t>(100000, true);
+ TestRunOobCheckedLoadT_pseudo<float>(100000, false);
+ TestRunOobCheckedLoadT_pseudo<float>(100000, true);
+ TestRunOobCheckedLoadT_pseudo<double>(100000, false);
+ TestRunOobCheckedLoadT_pseudo<double>(100000, true);
+}
+
+TEST(RunOobCheckedLoadT_pseudo2) {
+ TestRunOobCheckedLoadT_pseudo<int32_t>(A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<int32_t>(A_BILLION, true);
+ TestRunOobCheckedLoadT_pseudo<float>(A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<float>(A_BILLION, true);
+ TestRunOobCheckedLoadT_pseudo<double>(A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<double>(A_BILLION, true);
+}
+
+TEST(RunOobCheckedLoadT_pseudo3) {
+ TestRunOobCheckedLoadT_pseudo<int32_t>(A_GIG, false);
+ TestRunOobCheckedLoadT_pseudo<int32_t>(A_GIG, true);
+ TestRunOobCheckedLoadT_pseudo<float>(A_GIG, false);
+ TestRunOobCheckedLoadT_pseudo<float>(A_GIG, true);
+ TestRunOobCheckedLoadT_pseudo<double>(A_GIG, false);
+ TestRunOobCheckedLoadT_pseudo<double>(A_GIG, true);
+}
+
+TEST(RunOobCheckedLoadT_pseudo4) {
+ TestRunOobCheckedLoadT_pseudo<int32_t>(2 * A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<int32_t>(2 * A_BILLION, true);
+ TestRunOobCheckedLoadT_pseudo<float>(2 * A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<float>(2 * A_BILLION, true);
+ TestRunOobCheckedLoadT_pseudo<double>(2 * A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<double>(2 * A_BILLION, true);
+}
+
+TEST(RunOobCheckedLoadT_pseudo5) {
+ TestRunOobCheckedLoadT_pseudo<int32_t>(2 * A_GIG, false);
+ TestRunOobCheckedLoadT_pseudo<int32_t>(2 * A_GIG, true);
+ TestRunOobCheckedLoadT_pseudo<float>(2 * A_GIG, false);
+ TestRunOobCheckedLoadT_pseudo<float>(2 * A_GIG, true);
+ TestRunOobCheckedLoadT_pseudo<double>(2 * A_GIG, false);
+ TestRunOobCheckedLoadT_pseudo<double>(2 * A_GIG, true);
+}
+
+TEST(RunOobCheckedLoadT_pseudo6) {
+ TestRunOobCheckedLoadT_pseudo<int32_t>(3 * A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<int32_t>(3 * A_BILLION, true);
+ TestRunOobCheckedLoadT_pseudo<float>(3 * A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<float>(3 * A_BILLION, true);
+ TestRunOobCheckedLoadT_pseudo<double>(3 * A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<double>(3 * A_BILLION, true);
+}
+
+TEST(RunOobCheckedLoadT_pseudo7) {
+ TestRunOobCheckedLoadT_pseudo<int32_t>(3 * A_GIG, false);
+ TestRunOobCheckedLoadT_pseudo<int32_t>(3 * A_GIG, true);
+ TestRunOobCheckedLoadT_pseudo<float>(3 * A_GIG, false);
+ TestRunOobCheckedLoadT_pseudo<float>(3 * A_GIG, true);
+ TestRunOobCheckedLoadT_pseudo<double>(3 * A_GIG, false);
+ TestRunOobCheckedLoadT_pseudo<double>(3 * A_GIG, true);
+}
+
+TEST(RunOobCheckedLoadT_pseudo8) {
+ TestRunOobCheckedLoadT_pseudo<int32_t>(4 * A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<int32_t>(4 * A_BILLION, true);
+ TestRunOobCheckedLoadT_pseudo<float>(4 * A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<float>(4 * A_BILLION, true);
+ TestRunOobCheckedLoadT_pseudo<double>(4 * A_BILLION, false);
+ TestRunOobCheckedLoadT_pseudo<double>(4 * A_BILLION, true);
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/compiler/test-run-machops.cc b/test/cctest/compiler/test-run-machops.cc
index 2bfe124..6d681bc 100644
--- a/test/cctest/compiler/test-run-machops.cc
+++ b/test/cctest/compiler/test-run-machops.cc
@@ -28,6 +28,39 @@
CHECK_EQ(1, m.Call());
}
+static int RunInt32AddShift(bool is_left, int32_t add_left, int32_t add_right,
+ int32_t shift_left, int32_t shit_right) {
+ RawMachineAssemblerTester<int32_t> m;
+ Node* shift =
+ m.Word32Shl(m.Int32Constant(shift_left), m.Int32Constant(shit_right));
+ Node* add = m.Int32Add(m.Int32Constant(add_left), m.Int32Constant(add_right));
+ Node* lsa = is_left ? m.Int32Add(shift, add) : m.Int32Add(add, shift);
+ m.Return(lsa);
+ return m.Call();
+}
+
+TEST(RunInt32AddShift) {
+ struct Test_case {
+ int32_t add_left, add_right, shift_left, shit_right, expected;
+ };
+
+ Test_case tc[] = {
+ {20, 22, 4, 2, 58},
+ {20, 22, 4, 1, 50},
+ {20, 22, 1, 6, 106},
+ {INT_MAX - 2, 1, 1, 1, INT_MIN}, // INT_MAX - 2 + 1 + (1 << 1), overflow.
+ };
+ const size_t tc_size = sizeof(tc) / sizeof(Test_case);
+
+ for (size_t i = 0; i < tc_size; ++i) {
+ CHECK_EQ(tc[i].expected,
+ RunInt32AddShift(false, tc[i].add_left, tc[i].add_right,
+ tc[i].shift_left, tc[i].shit_right));
+ CHECK_EQ(tc[i].expected,
+ RunInt32AddShift(true, tc[i].add_left, tc[i].add_right,
+ tc[i].shift_left, tc[i].shit_right));
+ }
+}
TEST(RunWord32ReverseBits) {
BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Uint32());
@@ -636,6 +669,38 @@
}
}
+static int64_t RunInt64AddShift(bool is_left, int64_t add_left,
+ int64_t add_right, int64_t shift_left,
+ int64_t shit_right) {
+ RawMachineAssemblerTester<int64_t> m;
+ Node* shift = m.Word64Shl(m.Int64Constant(4), m.Int64Constant(2));
+ Node* add = m.Int64Add(m.Int64Constant(20), m.Int64Constant(22));
+ Node* dlsa = is_left ? m.Int64Add(shift, add) : m.Int64Add(add, shift);
+ m.Return(dlsa);
+ return m.Call();
+}
+
+TEST(RunInt64AddShift) {
+ struct Test_case {
+ int64_t add_left, add_right, shift_left, shit_right, expected;
+ };
+
+ Test_case tc[] = {
+ {20, 22, 4, 2, 58},
+ {20, 22, 4, 1, 50},
+ {20, 22, 1, 6, 106},
+ {INT64_MAX - 2, 1, 1, 1,
+ INT64_MIN}, // INT64_MAX - 2 + 1 + (1 << 1), overflow.
+ };
+ const size_t tc_size = sizeof(tc) / sizeof(Test_case);
+
+ for (size_t i = 0; i < tc_size; ++i) {
+ CHECK_EQ(58, RunInt64AddShift(false, tc[i].add_left, tc[i].add_right,
+ tc[i].shift_left, tc[i].shit_right));
+ CHECK_EQ(58, RunInt64AddShift(true, tc[i].add_left, tc[i].add_right,
+ tc[i].shift_left, tc[i].shit_right));
+ }
+}
// TODO(titzer): add tests that run 64-bit integer operations.
#endif // V8_TARGET_ARCH_64_BIT
@@ -1142,94 +1207,6 @@
}
-TEST(RunLoadInt32) {
- RawMachineAssemblerTester<int32_t> m;
-
- int32_t p1 = 0; // loads directly from this location.
- m.Return(m.LoadFromPointer(&p1, MachineType::Int32()));
-
- FOR_INT32_INPUTS(i) {
- p1 = *i;
- CHECK_EQ(p1, m.Call());
- }
-}
-
-
-TEST(RunLoadInt32Offset) {
- int32_t p1 = 0; // loads directly from this location.
-
- int32_t offsets[] = {-2000000, -100, -101, 1, 3,
- 7, 120, 2000, 2000000000, 0xff};
-
- for (size_t i = 0; i < arraysize(offsets); i++) {
- RawMachineAssemblerTester<int32_t> m;
- int32_t offset = offsets[i];
- byte* pointer = reinterpret_cast<byte*>(&p1) - offset;
- // generate load [#base + #index]
- m.Return(m.LoadFromPointer(pointer, MachineType::Int32(), offset));
-
- FOR_INT32_INPUTS(j) {
- p1 = *j;
- CHECK_EQ(p1, m.Call());
- }
- }
-}
-
-
-TEST(RunLoadStoreFloat32Offset) {
- float p1 = 0.0f; // loads directly from this location.
- float p2 = 0.0f; // and stores directly into this location.
-
- FOR_INT32_INPUTS(i) {
- int32_t magic = 0x2342aabb + *i * 3;
- RawMachineAssemblerTester<int32_t> m;
- int32_t offset = *i;
- byte* from = reinterpret_cast<byte*>(&p1) - offset;
- byte* to = reinterpret_cast<byte*>(&p2) - offset;
- // generate load [#base + #index]
- Node* load = m.Load(MachineType::Float32(), m.PointerConstant(from),
- m.IntPtrConstant(offset));
- m.Store(MachineRepresentation::kFloat32, m.PointerConstant(to),
- m.IntPtrConstant(offset), load, kNoWriteBarrier);
- m.Return(m.Int32Constant(magic));
-
- FOR_FLOAT32_INPUTS(j) {
- p1 = *j;
- p2 = *j - 5;
- CHECK_EQ(magic, m.Call());
- CHECK_DOUBLE_EQ(p1, p2);
- }
- }
-}
-
-
-TEST(RunLoadStoreFloat64Offset) {
- double p1 = 0; // loads directly from this location.
- double p2 = 0; // and stores directly into this location.
-
- FOR_INT32_INPUTS(i) {
- int32_t magic = 0x2342aabb + *i * 3;
- RawMachineAssemblerTester<int32_t> m;
- int32_t offset = *i;
- byte* from = reinterpret_cast<byte*>(&p1) - offset;
- byte* to = reinterpret_cast<byte*>(&p2) - offset;
- // generate load [#base + #index]
- Node* load = m.Load(MachineType::Float64(), m.PointerConstant(from),
- m.IntPtrConstant(offset));
- m.Store(MachineRepresentation::kFloat64, m.PointerConstant(to),
- m.IntPtrConstant(offset), load, kNoWriteBarrier);
- m.Return(m.Int32Constant(magic));
-
- FOR_FLOAT64_INPUTS(j) {
- p1 = *j;
- p2 = *j - 5;
- CHECK_EQ(magic, m.Call());
- CHECK_DOUBLE_EQ(p1, p2);
- }
- }
-}
-
-
TEST(RunInt32AddP) {
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
@@ -1709,7 +1686,6 @@
}
}
-
TEST(RunInt32SubImm) {
{
FOR_UINT32_INPUTS(i) {
@@ -1733,6 +1709,11 @@
}
}
+TEST(RunInt32SubImm2) {
+ BufferedRawMachineAssemblerTester<int32_t> r;
+ r.Return(r.Int32Sub(r.Int32Constant(-1), r.Int32Constant(0)));
+ CHECK_EQ(-1, r.Call());
+}
TEST(RunInt32SubAndWord32SarP) {
{
@@ -3566,92 +3547,6 @@
}
-template <typename Type>
-static void RunLoadImmIndex(MachineType rep) {
- const int kNumElems = 3;
- Type buffer[kNumElems];
-
- // initialize the buffer with some raw data.
- byte* raw = reinterpret_cast<byte*>(buffer);
- for (size_t i = 0; i < sizeof(buffer); i++) {
- raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
- }
-
- // Test with various large and small offsets.
- for (int offset = -1; offset <= 200000; offset *= -5) {
- for (int i = 0; i < kNumElems; i++) {
- BufferedRawMachineAssemblerTester<Type> m;
- Node* base = m.PointerConstant(buffer - offset);
- Node* index = m.Int32Constant((offset + i) * sizeof(buffer[0]));
- m.Return(m.Load(rep, base, index));
-
- volatile Type expected = buffer[i];
- volatile Type actual = m.Call();
- CHECK_EQ(expected, actual);
- }
- }
-}
-
-
-TEST(RunLoadImmIndex) {
- RunLoadImmIndex<int8_t>(MachineType::Int8());
- RunLoadImmIndex<uint8_t>(MachineType::Uint8());
- RunLoadImmIndex<int16_t>(MachineType::Int16());
- RunLoadImmIndex<uint16_t>(MachineType::Uint16());
- RunLoadImmIndex<int32_t>(MachineType::Int32());
- RunLoadImmIndex<uint32_t>(MachineType::Uint32());
- RunLoadImmIndex<int32_t*>(MachineType::AnyTagged());
- RunLoadImmIndex<float>(MachineType::Float32());
- RunLoadImmIndex<double>(MachineType::Float64());
- if (kPointerSize == 8) {
- RunLoadImmIndex<int64_t>(MachineType::Int64());
- }
- // TODO(titzer): test various indexing modes.
-}
-
-
-template <typename CType>
-static void RunLoadStore(MachineType rep) {
- const int kNumElems = 4;
- CType buffer[kNumElems];
-
- for (int32_t x = 0; x < kNumElems; x++) {
- int32_t y = kNumElems - x - 1;
- // initialize the buffer with raw data.
- byte* raw = reinterpret_cast<byte*>(buffer);
- for (size_t i = 0; i < sizeof(buffer); i++) {
- raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
- }
-
- RawMachineAssemblerTester<int32_t> m;
- int32_t OK = 0x29000 + x;
- Node* base = m.PointerConstant(buffer);
- Node* index0 = m.IntPtrConstant(x * sizeof(buffer[0]));
- Node* load = m.Load(rep, base, index0);
- Node* index1 = m.IntPtrConstant(y * sizeof(buffer[0]));
- m.Store(rep.representation(), base, index1, load, kNoWriteBarrier);
- m.Return(m.Int32Constant(OK));
-
- CHECK(buffer[x] != buffer[y]);
- CHECK_EQ(OK, m.Call());
- CHECK(buffer[x] == buffer[y]);
- }
-}
-
-
-TEST(RunLoadStore) {
- RunLoadStore<int8_t>(MachineType::Int8());
- RunLoadStore<uint8_t>(MachineType::Uint8());
- RunLoadStore<int16_t>(MachineType::Int16());
- RunLoadStore<uint16_t>(MachineType::Uint16());
- RunLoadStore<int32_t>(MachineType::Int32());
- RunLoadStore<uint32_t>(MachineType::Uint32());
- RunLoadStore<void*>(MachineType::AnyTagged());
- RunLoadStore<float>(MachineType::Float32());
- RunLoadStore<double>(MachineType::Float64());
-}
-
-
TEST(RunFloat32Add) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
MachineType::Float32());
@@ -4124,7 +4019,7 @@
m.Return(m.TruncateFloat32ToUint32(m.Parameter(0)));
{
FOR_UINT32_INPUTS(i) {
- float input = static_cast<float>(*i);
+ volatile float input = static_cast<float>(*i);
// This condition on 'input' is required because
// static_cast<float>(std::numeric_limits<uint32_t>::max()) results in a
// value outside uint32 range.
@@ -4201,7 +4096,7 @@
return (static_cast<uint64_t>(high) << 32) | static_cast<uint64_t>(low);
}
-#if V8_TARGET_ARCH_32_BIT && !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_X87
+#if V8_TARGET_ARCH_32_BIT && !V8_TARGET_ARCH_X87
TEST(RunInt32PairAdd) {
BufferedRawMachineAssemblerTester<int32_t> m(
MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
@@ -4449,6 +4344,56 @@
TestWord32PairShlWithSharedInput(1, 1);
}
+TEST(RunWord32PairShr) {
+ BufferedRawMachineAssemblerTester<int32_t> m(
+ MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
+
+ uint32_t high;
+ uint32_t low;
+
+ Node* PairAdd =
+ m.Word32PairShr(m.Parameter(0), m.Parameter(1), m.Parameter(2));
+
+ m.StoreToPointer(&low, MachineRepresentation::kWord32,
+ m.Projection(0, PairAdd));
+ m.StoreToPointer(&high, MachineRepresentation::kWord32,
+ m.Projection(1, PairAdd));
+ m.Return(m.Int32Constant(74));
+
+ FOR_UINT64_INPUTS(i) {
+ for (uint32_t j = 0; j < 64; j++) {
+ m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+ static_cast<uint32_t>(*i >> 32), j);
+ CHECK_EQ(*i >> j, ToInt64(low, high));
+ }
+ }
+}
+
+TEST(RunWord32PairSar) {
+ BufferedRawMachineAssemblerTester<int32_t> m(
+ MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
+
+ uint32_t high;
+ uint32_t low;
+
+ Node* PairAdd =
+ m.Word32PairSar(m.Parameter(0), m.Parameter(1), m.Parameter(2));
+
+ m.StoreToPointer(&low, MachineRepresentation::kWord32,
+ m.Projection(0, PairAdd));
+ m.StoreToPointer(&high, MachineRepresentation::kWord32,
+ m.Projection(1, PairAdd));
+ m.Return(m.Int32Constant(74));
+
+ FOR_INT64_INPUTS(i) {
+ for (uint32_t j = 0; j < 64; j++) {
+ m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+ static_cast<uint32_t>(*i >> 32), j);
+ CHECK_EQ(*i >> j, ToInt64(low, high));
+ }
+ }
+}
+
#endif
TEST(RunDeadChangeFloat64ToInt32) {
@@ -4968,45 +4913,6 @@
}
-template <typename IntType>
-static void LoadStoreTruncation(MachineType kRepresentation) {
- IntType input;
-
- RawMachineAssemblerTester<int32_t> m;
- Node* a = m.LoadFromPointer(&input, kRepresentation);
- Node* ap1 = m.Int32Add(a, m.Int32Constant(1));
- m.StoreToPointer(&input, kRepresentation.representation(), ap1);
- m.Return(ap1);
-
- const IntType max = std::numeric_limits<IntType>::max();
- const IntType min = std::numeric_limits<IntType>::min();
-
- // Test upper bound.
- input = max;
- CHECK_EQ(max + 1, m.Call());
- CHECK_EQ(min, input);
-
- // Test lower bound.
- input = min;
- CHECK_EQ(static_cast<IntType>(max + 2), m.Call());
- CHECK_EQ(min + 1, input);
-
- // Test all one byte values that are not one byte bounds.
- for (int i = -127; i < 127; i++) {
- input = i;
- int expected = i >= 0 ? i + 1 : max + (i - min) + 2;
- CHECK_EQ(static_cast<IntType>(expected), m.Call());
- CHECK_EQ(static_cast<IntType>(i + 1), input);
- }
-}
-
-
-TEST(RunLoadStoreTruncation) {
- LoadStoreTruncation<int8_t>(MachineType::Int8());
- LoadStoreTruncation<int16_t>(MachineType::Int16());
-}
-
-
static void IntPtrCompare(intptr_t left, intptr_t right) {
for (int test = 0; test < 7; test++) {
RawMachineAssemblerTester<bool> m(MachineType::Pointer(),
@@ -5417,8 +5323,7 @@
}
}
-
-TEST(RunTruncateFloat64ToInt32P) {
+TEST(RunTruncateFloat64ToWord32P) {
struct {
double from;
double raw;
@@ -5479,8 +5384,7 @@
{-1.7976931348623157e+308, 0}};
double input = -1.0;
RawMachineAssemblerTester<int32_t> m;
- m.Return(m.TruncateFloat64ToInt32(
- TruncationMode::kJavaScript,
+ m.Return(m.TruncateFloat64ToWord32(
m.LoadFromPointer(&input, MachineType::Float64())));
for (size_t i = 0; i < arraysize(kValues); ++i) {
input = kValues[i].from;
@@ -5489,6 +5393,12 @@
}
}
+TEST(RunTruncateFloat64ToWord32SignExtension) {
+ BufferedRawMachineAssemblerTester<int32_t> r;
+ r.Return(r.Int32Sub(r.TruncateFloat64ToWord32(r.Float64Constant(-1.0)),
+ r.Int32Constant(0)));
+ CHECK_EQ(-1, r.Call());
+}
TEST(RunChangeFloat32ToFloat64) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float32());
@@ -5854,50 +5764,6 @@
#if V8_TARGET_ARCH_64_BIT
// TODO(titzer): run int64 tests on all platforms when supported.
-TEST(RunCheckedLoadInt64) {
- int64_t buffer[] = {0x66bbccddeeff0011LL, 0x1122334455667788LL};
- RawMachineAssemblerTester<int64_t> m(MachineType::Int32());
- Node* base = m.PointerConstant(buffer);
- Node* index = m.Parameter(0);
- Node* length = m.Int32Constant(16);
- Node* load = m.AddNode(m.machine()->CheckedLoad(MachineType::Int64()), base,
- index, length);
- m.Return(load);
-
- CHECK_EQ(buffer[0], m.Call(0));
- CHECK_EQ(buffer[1], m.Call(8));
- CHECK_EQ(0, m.Call(16));
-}
-
-
-TEST(RunCheckedStoreInt64) {
- const int64_t write = 0x5566778899aabbLL;
- const int64_t before = 0x33bbccddeeff0011LL;
- int64_t buffer[] = {before, before};
- RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
- Node* base = m.PointerConstant(buffer);
- Node* index = m.Parameter(0);
- Node* length = m.Int32Constant(16);
- Node* value = m.Int64Constant(write);
- Node* store =
- m.AddNode(m.machine()->CheckedStore(MachineRepresentation::kWord64), base,
- index, length, value);
- USE(store);
- m.Return(m.Int32Constant(11));
-
- CHECK_EQ(11, m.Call(16));
- CHECK_EQ(before, buffer[0]);
- CHECK_EQ(before, buffer[1]);
-
- CHECK_EQ(11, m.Call(0));
- CHECK_EQ(write, buffer[0]);
- CHECK_EQ(before, buffer[1]);
-
- CHECK_EQ(11, m.Call(8));
- CHECK_EQ(write, buffer[0]);
- CHECK_EQ(write, buffer[1]);
-}
-
TEST(RunBitcastInt64ToFloat64) {
int64_t input = 1;
diff --git a/test/cctest/compiler/test-run-native-calls.cc b/test/cctest/compiler/test-run-native-calls.cc
index bfdcc0e..a63cc8a 100644
--- a/test/cctest/compiler/test-run-native-calls.cc
+++ b/test/cctest/compiler/test-run-native-calls.cc
@@ -255,7 +255,7 @@
Handle<Code> CompileGraph(const char* name, CallDescriptor* desc, Graph* graph,
Schedule* schedule = nullptr) {
Isolate* isolate = CcTest::InitIsolateOnce();
- CompilationInfo info("testing", isolate, graph->zone());
+ CompilationInfo info(ArrayVector("testing"), isolate, graph->zone());
Handle<Code> code =
Pipeline::GenerateCodeForTesting(&info, desc, graph, schedule);
CHECK(!code.is_null());
diff --git a/test/cctest/compiler/test-run-stubs.cc b/test/cctest/compiler/test-run-stubs.cc
index c745219..feb25c9 100644
--- a/test/cctest/compiler/test-run-stubs.cc
+++ b/test/cctest/compiler/test-run-stubs.cc
@@ -27,7 +27,7 @@
// Create code and an accompanying descriptor.
StringLengthStub stub(isolate);
Handle<Code> code = stub.GenerateCode();
- CompilationInfo info("test", isolate, zone,
+ CompilationInfo info(ArrayVector("test"), isolate, zone,
Code::ComputeFlags(Code::HANDLER));
CallInterfaceDescriptor interface_descriptor =
stub.GetCallInterfaceDescriptor();
diff --git a/test/cctest/compiler/test-run-wasm-machops.cc b/test/cctest/compiler/test-run-wasm-machops.cc
new file mode 100644
index 0000000..0b23669
--- /dev/null
+++ b/test/cctest/compiler/test-run-wasm-machops.cc
@@ -0,0 +1,170 @@
+// Copyright 2016 the V8 project authors. All rights reserved. Use of this
+// source code is governed by a BSD-style license that can be found in the
+// LICENSE file.
+
+#include <cmath>
+#include <functional>
+#include <limits>
+
+#include "src/base/bits.h"
+#include "src/base/utils/random-number-generator.h"
+#include "src/codegen.h"
+#include "test/cctest/cctest.h"
+#include "test/cctest/compiler/codegen-tester.h"
+#include "test/cctest/compiler/graph-builder-tester.h"
+#include "test/cctest/compiler/value-helper.h"
+
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+
+static void UpdateMemoryReferences(Handle<Code> code, Address old_base,
+ Address new_base, uint32_t old_size,
+ uint32_t new_size) {
+ Isolate* isolate = CcTest::i_isolate();
+ bool modified = false;
+ int mode_mask = RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_REFERENCE) |
+ RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+ for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
+ RelocInfo::Mode mode = it.rinfo()->rmode();
+ if (RelocInfo::IsWasmMemoryReference(mode) ||
+ RelocInfo::IsWasmMemorySizeReference(mode)) {
+ // Patch addresses with change in memory start address
+ it.rinfo()->update_wasm_memory_reference(old_base, new_base, old_size,
+ new_size);
+ modified = true;
+ }
+ }
+ if (modified) {
+ Assembler::FlushICache(isolate, code->instruction_start(),
+ code->instruction_size());
+ }
+}
+
+template <typename CType>
+static void RunLoadStoreRelocation(MachineType rep) {
+ const int kNumElems = 2;
+ CType buffer[kNumElems];
+ CType new_buffer[kNumElems];
+ byte* raw = reinterpret_cast<byte*>(buffer);
+ byte* new_raw = reinterpret_cast<byte*>(new_buffer);
+ for (size_t i = 0; i < sizeof(buffer); i++) {
+ raw[i] = static_cast<byte>((i + sizeof(CType)) ^ 0xAA);
+ new_raw[i] = static_cast<byte>((i + sizeof(CType)) ^ 0xAA);
+ }
+ int32_t OK = 0x29000;
+ RawMachineAssemblerTester<uint32_t> m;
+ Node* base = m.RelocatableIntPtrConstant(reinterpret_cast<intptr_t>(raw),
+ RelocInfo::WASM_MEMORY_REFERENCE);
+ Node* base1 = m.RelocatableIntPtrConstant(
+ reinterpret_cast<intptr_t>(raw + sizeof(CType)),
+ RelocInfo::WASM_MEMORY_REFERENCE);
+ Node* index = m.Int32Constant(0);
+ Node* load = m.Load(rep, base, index);
+ m.Store(rep.representation(), base1, index, load, kNoWriteBarrier);
+ m.Return(m.Int32Constant(OK));
+ CHECK(buffer[0] != buffer[1]);
+ CHECK_EQ(OK, m.Call());
+ CHECK(buffer[0] == buffer[1]);
+ m.GenerateCode();
+ Handle<Code> code = m.GetCode();
+ UpdateMemoryReferences(code, raw, new_raw, sizeof(buffer),
+ sizeof(new_buffer));
+ CHECK(new_buffer[0] != new_buffer[1]);
+ CHECK_EQ(OK, m.Call());
+ CHECK(new_buffer[0] == new_buffer[1]);
+}
+
+TEST(RunLoadStoreRelocation) {
+ RunLoadStoreRelocation<int8_t>(MachineType::Int8());
+ RunLoadStoreRelocation<uint8_t>(MachineType::Uint8());
+ RunLoadStoreRelocation<int16_t>(MachineType::Int16());
+ RunLoadStoreRelocation<uint16_t>(MachineType::Uint16());
+ RunLoadStoreRelocation<int32_t>(MachineType::Int32());
+ RunLoadStoreRelocation<uint32_t>(MachineType::Uint32());
+ RunLoadStoreRelocation<void*>(MachineType::AnyTagged());
+ RunLoadStoreRelocation<float>(MachineType::Float32());
+ RunLoadStoreRelocation<double>(MachineType::Float64());
+}
+
+template <typename CType>
+static void RunLoadStoreRelocationOffset(MachineType rep) {
+ RawMachineAssemblerTester<int32_t> r(MachineType::Int32());
+ const int kNumElems = 4;
+ CType buffer[kNumElems];
+ CType new_buffer[kNumElems + 1];
+
+ for (int32_t x = 0; x < kNumElems; x++) {
+ int32_t y = kNumElems - x - 1;
+ // initialize the buffer with raw data.
+ byte* raw = reinterpret_cast<byte*>(buffer);
+ for (size_t i = 0; i < sizeof(buffer); i++) {
+ raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
+ }
+
+ RawMachineAssemblerTester<int32_t> m;
+ int32_t OK = 0x29000 + x;
+ Node* base = m.RelocatableIntPtrConstant(reinterpret_cast<intptr_t>(buffer),
+ RelocInfo::WASM_MEMORY_REFERENCE);
+ Node* index0 = m.IntPtrConstant(x * sizeof(buffer[0]));
+ Node* load = m.Load(rep, base, index0);
+ Node* index1 = m.IntPtrConstant(y * sizeof(buffer[0]));
+ m.Store(rep.representation(), base, index1, load, kNoWriteBarrier);
+ m.Return(m.Int32Constant(OK));
+
+ CHECK(buffer[x] != buffer[y]);
+ CHECK_EQ(OK, m.Call());
+ CHECK(buffer[x] == buffer[y]);
+ m.GenerateCode();
+
+ // Initialize new buffer and set old_buffer to 0
+ byte* new_raw = reinterpret_cast<byte*>(new_buffer);
+ for (size_t i = 0; i < sizeof(buffer); i++) {
+ raw[i] = 0;
+ new_raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
+ }
+
+ // Perform relocation on generated code
+ Handle<Code> code = m.GetCode();
+ UpdateMemoryReferences(code, raw, new_raw, sizeof(buffer),
+ sizeof(new_buffer));
+
+ CHECK(new_buffer[x] != new_buffer[y]);
+ CHECK_EQ(OK, m.Call());
+ CHECK(new_buffer[x] == new_buffer[y]);
+ }
+}
+
+TEST(RunLoadStoreRelocationOffset) {
+ RunLoadStoreRelocationOffset<int8_t>(MachineType::Int8());
+ RunLoadStoreRelocationOffset<uint8_t>(MachineType::Uint8());
+ RunLoadStoreRelocationOffset<int16_t>(MachineType::Int16());
+ RunLoadStoreRelocationOffset<uint16_t>(MachineType::Uint16());
+ RunLoadStoreRelocationOffset<int32_t>(MachineType::Int32());
+ RunLoadStoreRelocationOffset<uint32_t>(MachineType::Uint32());
+ RunLoadStoreRelocationOffset<void*>(MachineType::AnyTagged());
+ RunLoadStoreRelocationOffset<float>(MachineType::Float32());
+ RunLoadStoreRelocationOffset<double>(MachineType::Float64());
+}
+
+TEST(Uint32LessThanRelocation) {
+ RawMachineAssemblerTester<uint32_t> m;
+ RawMachineLabel within_bounds, out_of_bounds;
+ Node* index = m.Int32Constant(0x200);
+ Node* limit =
+ m.RelocatableInt32Constant(0x200, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+ Node* cond = m.AddNode(m.machine()->Uint32LessThan(), index, limit);
+ m.Branch(cond, &within_bounds, &out_of_bounds);
+ m.Bind(&within_bounds);
+ m.Return(m.Int32Constant(0xaced));
+ m.Bind(&out_of_bounds);
+ m.Return(m.Int32Constant(0xdeadbeef));
+ // Check that index is out of bounds with current size
+ CHECK_EQ(0xdeadbeef, m.Call());
+ m.GenerateCode();
+
+ Handle<Code> code = m.GetCode();
+ UpdateMemoryReferences(code, reinterpret_cast<Address>(1234),
+ reinterpret_cast<Address>(1234), 0x200, 0x400);
+ // Check that after limit is increased, index is within bounds.
+ CHECK_EQ(0xaced, m.Call());
+}
diff --git a/test/cctest/compiler/test-simplified-lowering.cc b/test/cctest/compiler/test-simplified-lowering.cc
index b5e9929..4efb149 100644
--- a/test/cctest/compiler/test-simplified-lowering.cc
+++ b/test/cctest/compiler/test-simplified-lowering.cc
@@ -6,13 +6,14 @@
#include "src/ast/scopes.h"
#include "src/compiler/access-builder.h"
-#include "src/compiler/change-lowering.h"
#include "src/compiler/control-builders.h"
-#include "src/compiler/graph-reducer.h"
+#include "src/compiler/effect-control-linearizer.h"
#include "src/compiler/graph-visualizer.h"
+#include "src/compiler/memory-optimizer.h"
#include "src/compiler/node-properties.h"
#include "src/compiler/pipeline.h"
#include "src/compiler/representation-change.h"
+#include "src/compiler/scheduler.h"
#include "src/compiler/simplified-lowering.h"
#include "src/compiler/source-position.h"
#include "src/compiler/typer.h"
@@ -60,11 +61,13 @@
typer.Run();
lowering.LowerAllNodes();
- ChangeLowering lowering(&jsgraph);
- GraphReducer reducer(this->zone(), this->graph());
- reducer.AddReducer(&lowering);
- reducer.ReduceGraph();
- Verifier::Run(this->graph());
+ Schedule* schedule = Scheduler::ComputeSchedule(this->zone(), this->graph(),
+ Scheduler::kNoFlags);
+ EffectControlLinearizer linearizer(&jsgraph, schedule, this->zone());
+ linearizer.Run();
+
+ MemoryOptimizer memory_optimizer(&jsgraph, this->zone());
+ memory_optimizer.Optimize();
}
void CheckNumberCall(double expected, double input) {
@@ -99,13 +102,15 @@
double input;
int32_t result;
SimplifiedLoweringTester<Object*> t;
- FieldAccess load = {kUntaggedBase, 0, Handle<Name>(), Type::Number(),
- MachineType::Float64()};
+ FieldAccess load = {kUntaggedBase, 0,
+ Handle<Name>(), Type::Number(),
+ MachineType::Float64(), kNoWriteBarrier};
Node* loaded = t.LoadField(load, t.PointerConstant(&input));
NodeProperties::SetType(loaded, Type::Number());
Node* convert = t.NumberToInt32(loaded);
- FieldAccess store = {kUntaggedBase, 0, Handle<Name>(), Type::Signed32(),
- MachineType::Int32()};
+ FieldAccess store = {kUntaggedBase, 0,
+ Handle<Name>(), Type::Signed32(),
+ MachineType::Int32(), kNoWriteBarrier};
t.StoreField(store, t.PointerConstant(&result), convert);
t.Return(t.jsgraph.TrueConstant());
t.LowerAllNodesAndLowerChanges();
@@ -126,13 +131,15 @@
double input;
uint32_t result;
SimplifiedLoweringTester<Object*> t;
- FieldAccess load = {kUntaggedBase, 0, Handle<Name>(), Type::Number(),
- MachineType::Float64()};
+ FieldAccess load = {kUntaggedBase, 0,
+ Handle<Name>(), Type::Number(),
+ MachineType::Float64(), kNoWriteBarrier};
Node* loaded = t.LoadField(load, t.PointerConstant(&input));
NodeProperties::SetType(loaded, Type::Number());
Node* convert = t.NumberToUint32(loaded);
- FieldAccess store = {kUntaggedBase, 0, Handle<Name>(), Type::Unsigned32(),
- MachineType::Uint32()};
+ FieldAccess store = {kUntaggedBase, 0,
+ Handle<Name>(), Type::Unsigned32(),
+ MachineType::Uint32(), kNoWriteBarrier};
t.StoreField(store, t.PointerConstant(&result), convert);
t.Return(t.jsgraph.TrueConstant());
t.LowerAllNodesAndLowerChanges();
@@ -291,8 +298,12 @@
for (size_t i = 0; i < arraysize(smis); i++) {
int offset = static_cast<int>(i * sizeof(Smi*));
- FieldAccess access = {kUntaggedBase, offset, Handle<Name>(),
- Type::Integral32(), MachineType::AnyTagged()};
+ FieldAccess access = {kUntaggedBase,
+ offset,
+ Handle<Name>(),
+ Type::Integral32(),
+ MachineType::AnyTagged(),
+ kNoWriteBarrier};
SimplifiedLoweringTester<Object*> t;
Node* load = t.LoadField(access, t.PointerConstant(smis));
@@ -313,8 +324,12 @@
for (size_t i = 0; i < arraysize(smis); i++) {
int offset = static_cast<int>(i * sizeof(Smi*));
- FieldAccess access = {kUntaggedBase, offset, Handle<Name>(),
- Type::Integral32(), MachineType::AnyTagged()};
+ FieldAccess access = {kUntaggedBase,
+ offset,
+ Handle<Name>(),
+ Type::Integral32(),
+ MachineType::AnyTagged(),
+ kNoWriteBarrier};
SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* p0 = t.Parameter(0);
@@ -340,7 +355,7 @@
for (size_t j = 0; (i + j) < arraysize(smis); j++) { // for element index
int offset = static_cast<int>(i * sizeof(Smi*));
ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
- MachineType::AnyTagged()};
+ MachineType::AnyTagged(), kNoWriteBarrier};
SimplifiedLoweringTester<Object*> t;
Node* load = t.LoadElement(access, t.PointerConstant(smis),
@@ -366,7 +381,7 @@
for (size_t j = 0; (i + j) < arraysize(smis); j++) { // for element index
int offset = static_cast<int>(i * sizeof(Smi*));
ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
- MachineType::AnyTagged()};
+ MachineType::AnyTagged(), kNoWriteBarrier};
SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* p0 = t.Parameter(0);
@@ -518,7 +533,7 @@
ElementAccess GetElementAccess() {
ElementAccess access = {tagged ? kTaggedBase : kUntaggedBase,
tagged ? FixedArrayBase::kHeaderSize : 0,
- Type::Any(), rep};
+ Type::Any(), rep, kFullWriteBarrier};
return access;
}
@@ -526,7 +541,10 @@
int offset = field * sizeof(E);
FieldAccess access = {tagged ? kTaggedBase : kUntaggedBase,
offset + (tagged ? FixedArrayBase::kHeaderSize : 0),
- Handle<Name>(), Type::Any(), rep};
+ Handle<Name>(),
+ Type::Any(),
+ rep,
+ kFullWriteBarrier};
return access;
}
@@ -726,11 +744,13 @@
SourcePositionTable table(jsgraph.graph());
SimplifiedLowering(&jsgraph, jsgraph.zone(), &table).LowerAllNodes();
- ChangeLowering lowering(&jsgraph);
- GraphReducer reducer(this->zone(), this->graph());
- reducer.AddReducer(&lowering);
- reducer.ReduceGraph();
- Verifier::Run(this->graph());
+ Schedule* schedule = Scheduler::ComputeSchedule(this->zone(), this->graph(),
+ Scheduler::kNoFlags);
+ EffectControlLinearizer linearizer(&jsgraph, schedule, this->zone());
+ linearizer.Run();
+
+ MemoryOptimizer memory_optimizer(&jsgraph, this->zone());
+ memory_optimizer.Optimize();
}
// Inserts the node as the return value of the graph.
@@ -831,7 +851,7 @@
Node* use = t.Use(inv, MachineType::AnyTagged());
t.Return(use);
t.Lower();
- CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
+ CHECK_EQ(IrOpcode::kChangeBitToTagged, use->InputAt(0)->opcode());
Node* cmp = use->InputAt(0)->InputAt(0);
CHECK_EQ(t.machine()->Word32Equal()->opcode(), cmp->opcode());
CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
@@ -863,7 +883,7 @@
Node* use = t.Use(inv, MachineType::AnyTagged());
t.Return(use);
t.Lower();
- CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
+ CHECK_EQ(IrOpcode::kChangeBitToTagged, use->InputAt(0)->opcode());
Node* cmp = use->InputAt(0)->InputAt(0);
CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
@@ -908,7 +928,7 @@
t.Return(use);
t.Lower();
CHECK_EQ(b, use->InputAt(0)->InputAt(0));
- CHECK_EQ(IrOpcode::kChangeUint32ToTagged, use->InputAt(0)->opcode());
+ CHECK_EQ(IrOpcode::kChangeInt31ToTaggedSigned, use->InputAt(0)->opcode());
}
@@ -921,7 +941,7 @@
t.Return(use);
t.Lower();
CHECK_EQ(cnv, use->InputAt(0)->InputAt(0));
- CHECK_EQ(IrOpcode::kChangeUint32ToTagged, use->InputAt(0)->opcode());
+ CHECK_EQ(IrOpcode::kChangeInt31ToTaggedSigned, use->InputAt(0)->opcode());
CHECK_EQ(t.machine()->WordEqual()->opcode(), cnv->opcode());
CHECK(b == cnv->InputAt(0) || b == cnv->InputAt(1));
Node* c = t.jsgraph.TrueConstant();
@@ -1046,8 +1066,7 @@
CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p0, use->InputAt(0));
}
-
-TEST(LowerNumberToInt32_to_TruncateFloat64ToInt32) {
+TEST(LowerNumberToInt32_to_TruncateFloat64ToWord32) {
// NumberToInt32(x: kRepFloat64) used as MachineType::Int32()
TestingGraph t(Type::Number());
Node* p0 = t.ExampleWithOutput(MachineType::Float64());
@@ -1055,22 +1074,17 @@
Node* use = t.Use(trunc, MachineType::Int32());
t.Return(use);
t.Lower();
- CheckChangeOf(IrOpcode::kTruncateFloat64ToInt32, p0, use->InputAt(0));
+ CheckChangeOf(IrOpcode::kTruncateFloat64ToWord32, p0, use->InputAt(0));
}
-
-TEST(LowerNumberToInt32_to_TruncateFloat64ToInt32_with_change) {
+TEST(LowerNumberToInt32_to_TruncateTaggedToWord32) {
// NumberToInt32(x: kTypeNumber | kRepTagged) used as MachineType::Int32()
TestingGraph t(Type::Number());
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
Node* use = t.Use(trunc, MachineType::Int32());
t.Return(use);
t.Lower();
- Node* node = use->InputAt(0);
- CHECK_EQ(IrOpcode::kTruncateFloat64ToInt32, node->opcode());
- Node* of = node->InputAt(0);
- CHECK_EQ(IrOpcode::kChangeTaggedToFloat64, of->opcode());
- CHECK_EQ(t.p0, of->InputAt(0));
+ CheckChangeOf(IrOpcode::kTruncateTaggedToWord32, t.p0, use->InputAt(0));
}
@@ -1084,8 +1098,7 @@
CheckChangeOf(IrOpcode::kChangeTaggedToUint32, t.p0, use->InputAt(0));
}
-
-TEST(LowerNumberToUint32_to_TruncateFloat64ToInt32) {
+TEST(LowerNumberToUint32_to_TruncateFloat64ToWord32) {
// NumberToUint32(x: kRepFloat64) used as MachineType::Uint32()
TestingGraph t(Type::Number());
Node* p0 = t.ExampleWithOutput(MachineType::Float64());
@@ -1095,26 +1108,20 @@
Node* use = t.Use(trunc, MachineType::Uint32());
t.Return(use);
t.Lower();
- CheckChangeOf(IrOpcode::kTruncateFloat64ToInt32, p0, use->InputAt(0));
+ CheckChangeOf(IrOpcode::kTruncateFloat64ToWord32, p0, use->InputAt(0));
}
-
-TEST(LowerNumberToUint32_to_TruncateFloat64ToInt32_with_change) {
+TEST(LowerNumberToUint32_to_TruncateTaggedToWord32) {
// NumberToInt32(x: kTypeNumber | kRepTagged) used as MachineType::Uint32()
TestingGraph t(Type::Number());
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
Node* use = t.Use(trunc, MachineType::Uint32());
t.Return(use);
t.Lower();
- Node* node = use->InputAt(0);
- CHECK_EQ(IrOpcode::kTruncateFloat64ToInt32, node->opcode());
- Node* of = node->InputAt(0);
- CHECK_EQ(IrOpcode::kChangeTaggedToFloat64, of->opcode());
- CHECK_EQ(t.p0, of->InputAt(0));
+ CheckChangeOf(IrOpcode::kTruncateTaggedToWord32, t.p0, use->InputAt(0));
}
-
-TEST(LowerNumberToUint32_to_TruncateFloat64ToInt32_uint32) {
+TEST(LowerNumberToUint32_to_TruncateFloat64ToWord32_uint32) {
// NumberToUint32(x: kRepFloat64) used as kRepWord32
TestingGraph t(Type::Unsigned32());
Node* input = t.ExampleWithOutput(MachineType::Float64());
@@ -1122,7 +1129,7 @@
Node* use = t.Use(trunc, MachineType::RepWord32());
t.Return(use);
t.Lower();
- CheckChangeOf(IrOpcode::kTruncateFloat64ToInt32, input, use->InputAt(0));
+ CheckChangeOf(IrOpcode::kTruncateFloat64ToWord32, input, use->InputAt(0));
}
@@ -1150,7 +1157,7 @@
MachineType::Int32(), Type::Signed32());
CheckChangeInsertion(IrOpcode::kChangeFloat64ToUint32, MachineType::Float64(),
MachineType::Uint32(), Type::Unsigned32());
- CheckChangeInsertion(IrOpcode::kTruncateFloat64ToInt32,
+ CheckChangeInsertion(IrOpcode::kTruncateFloat64ToWord32,
MachineType::Float64(), MachineType::Uint32(),
Type::Integral32());
CheckChangeInsertion(IrOpcode::kChangeTaggedToInt32, MachineType::AnyTagged(),
@@ -1222,7 +1229,7 @@
for (size_t i = 0; i < arraysize(ops); i++) {
CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToInt32,
- IrOpcode::kChangeBitToBool);
+ IrOpcode::kChangeBitToTagged);
}
}
@@ -1235,7 +1242,7 @@
for (size_t i = 0; i < arraysize(ops); i++) {
CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToUint32,
- IrOpcode::kChangeBitToBool);
+ IrOpcode::kChangeBitToTagged);
}
}
@@ -1265,7 +1272,7 @@
for (size_t i = 0; i < arraysize(ops); i++) {
CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToFloat64,
- IrOpcode::kChangeBitToBool);
+ IrOpcode::kChangeBitToTagged);
}
}
@@ -1311,11 +1318,11 @@
TEST(LowerLoadField_to_load) {
- TestingGraph t(Type::Any(), Type::Signed32());
-
for (size_t i = 0; i < arraysize(kMachineReps); i++) {
- FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(), kMachineReps[i]};
+ TestingGraph t(Type::Any(), Type::Signed32());
+ FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
+ Handle<Name>::null(), Type::Any(),
+ kMachineReps[i], kNoWriteBarrier};
Node* load = t.graph()->NewNode(t.simplified()->LoadField(access), t.p0,
t.start, t.start);
@@ -1337,9 +1344,9 @@
TestingGraph t(Type::Any(), Type::Signed32());
for (size_t i = 0; i < arraysize(kMachineReps); i++) {
- FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(), kMachineReps[i]};
-
+ FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
+ Handle<Name>::null(), Type::Any(),
+ kMachineReps[i], kNoWriteBarrier};
Node* val = t.ExampleWithOutput(kMachineReps[i]);
Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
@@ -1352,7 +1359,7 @@
StoreRepresentation rep = StoreRepresentationOf(store->op());
if (kMachineReps[i].representation() == MachineRepresentation::kTagged) {
- CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());
+ CHECK_EQ(kNoWriteBarrier, rep.write_barrier_kind());
}
CHECK_EQ(kMachineReps[i].representation(), rep.representation());
}
@@ -1362,9 +1369,9 @@
Zone* z = scope.main_zone();
TestingGraph t(Type::Any(), Type::Intersect(Type::SignedSmall(),
Type::TaggedSigned(), z));
- FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(),
- MachineType::AnyTagged()};
+ FieldAccess access = {
+ kTaggedBase, FixedArrayBase::kHeaderSize, Handle<Name>::null(),
+ Type::Any(), MachineType::AnyTagged(), kNoWriteBarrier};
Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
t.p1, t.start, t.start);
t.Effect(store);
@@ -1378,11 +1385,10 @@
TEST(LowerLoadElement_to_load) {
- TestingGraph t(Type::Any(), Type::Signed32());
-
for (size_t i = 0; i < arraysize(kMachineReps); i++) {
+ TestingGraph t(Type::Any(), Type::Signed32());
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Type::Any(), kMachineReps[i]};
+ Type::Any(), kMachineReps[i], kNoWriteBarrier};
Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
t.p1, t.start, t.start);
@@ -1401,11 +1407,11 @@
TEST(LowerStoreElement_to_store) {
{
- TestingGraph t(Type::Any(), Type::Signed32());
-
for (size_t i = 0; i < arraysize(kMachineReps); i++) {
+ TestingGraph t(Type::Any(), Type::Signed32());
+
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Type::Any(), kMachineReps[i]};
+ Type::Any(), kMachineReps[i], kNoWriteBarrier};
Node* val = t.ExampleWithOutput(kMachineReps[i]);
Node* store = t.graph()->NewNode(t.simplified()->StoreElement(access),
@@ -1418,7 +1424,7 @@
StoreRepresentation rep = StoreRepresentationOf(store->op());
if (kMachineReps[i].representation() == MachineRepresentation::kTagged) {
- CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());
+ CHECK_EQ(kNoWriteBarrier, rep.write_barrier_kind());
}
CHECK_EQ(kMachineReps[i].representation(), rep.representation());
}
@@ -1430,7 +1436,8 @@
Type::Any(), Type::Signed32(),
Type::Intersect(Type::SignedSmall(), Type::TaggedSigned(), z));
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Type::Any(), MachineType::AnyTagged()};
+ Type::Any(), MachineType::AnyTagged(),
+ kNoWriteBarrier};
Node* store = t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
t.p1, t.p2, t.start, t.start);
t.Effect(store);
@@ -1448,7 +1455,7 @@
// Load(obj, Int32Add(Int32Mul(ChangeTaggedToInt32(index), #k), #k))
TestingGraph t(Type::Any(), Type::Signed32());
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
- MachineType::AnyTagged()};
+ MachineType::AnyTagged(), kNoWriteBarrier};
Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
t.p1, t.start, t.start);
@@ -1465,7 +1472,7 @@
// Store(obj, Int32Add(Int32Mul(ChangeTaggedToInt32(index), #k), #k), val)
TestingGraph t(Type::Any(), Type::Signed32());
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
- MachineType::AnyTagged()};
+ MachineType::AnyTagged(), kFullWriteBarrier};
Node* store =
t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0, t.p1,
@@ -1482,7 +1489,7 @@
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32(), Type::Any());
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
- MachineType::Float64()};
+ MachineType::Float64(), kNoWriteBarrier};
Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
t.p1, t.start, t.start);
@@ -1497,9 +1504,9 @@
TEST(InsertChangeForLoadField) {
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32());
- FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(),
- MachineType::Float64()};
+ FieldAccess access = {
+ kTaggedBase, FixedArrayBase::kHeaderSize, Handle<Name>::null(),
+ Type::Any(), MachineType::Float64(), kNoWriteBarrier};
Node* load = t.graph()->NewNode(t.simplified()->LoadField(access), t.p0,
t.start, t.start);
@@ -1515,7 +1522,7 @@
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32());
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
- MachineType::Float64()};
+ MachineType::Float64(), kFullWriteBarrier};
Node* store =
t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
@@ -1532,9 +1539,9 @@
TEST(InsertChangeForStoreField) {
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32());
- FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(),
- MachineType::Float64()};
+ FieldAccess access = {
+ kTaggedBase, FixedArrayBase::kHeaderSize, Handle<Name>::null(),
+ Type::Any(), MachineType::Float64(), kNoWriteBarrier};
Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
t.p1, t.start, t.start);
@@ -1554,8 +1561,9 @@
Type* kTypes[] = {Type::Signed32(), Type::Unsigned32(), Type::Number()};
for (size_t i = 0; i < arraysize(kMachineTypes); i++) {
- FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), kTypes[i], kMachineTypes[i]};
+ FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
+ Handle<Name>::null(), kTypes[i],
+ kMachineTypes[i], kFullWriteBarrier};
Node* load0 = t.graph()->NewNode(t.simplified()->LoadField(access), t.p0,
t.start, t.start);
diff --git a/test/cctest/expression-type-collector.cc b/test/cctest/expression-type-collector.cc
index c5218b3..f1289a7 100644
--- a/test/cctest/expression-type-collector.cc
+++ b/test/cctest/expression-type-collector.cc
@@ -6,6 +6,7 @@
#include "test/cctest/expression-type-collector.h"
+#include "src/ast/ast-type-bounds.h"
#include "src/ast/ast.h"
#include "src/ast/scopes.h"
#include "src/codegen.h"
@@ -27,12 +28,10 @@
} // namespace
-
ExpressionTypeCollector::ExpressionTypeCollector(
- Isolate* isolate, FunctionLiteral* root,
+ Isolate* isolate, FunctionLiteral* root, const AstTypeBounds* bounds,
ZoneVector<ExpressionTypeEntry>* dst)
- : AstExpressionVisitor(isolate, root), result_(dst) {}
-
+ : AstExpressionVisitor(isolate, root), bounds_(bounds), result_(dst) {}
void ExpressionTypeCollector::Run() {
result_->clear();
@@ -47,7 +46,7 @@
if (proxy) {
e.name = proxy->raw_name();
}
- e.bounds = expression->bounds();
+ e.bounds = bounds_->get(expression);
AstNode::NodeType type = expression->node_type();
e.kind = "unknown";
for (size_t i = 0; i < arraysize(NodeTypeNameList); ++i) {
diff --git a/test/cctest/expression-type-collector.h b/test/cctest/expression-type-collector.h
index 37bb9a3..a52cfda 100644
--- a/test/cctest/expression-type-collector.h
+++ b/test/cctest/expression-type-collector.h
@@ -10,6 +10,8 @@
namespace v8 {
namespace internal {
+class AstTypeBounds;
+
// A Visitor over an AST that collects a human readable string summarizing
// structure and types. Used for testing of the typing information attached
// to the expression nodes of an AST.
@@ -24,6 +26,7 @@
class ExpressionTypeCollector : public AstExpressionVisitor {
public:
ExpressionTypeCollector(Isolate* isolate, FunctionLiteral* root,
+ const AstTypeBounds* bounds,
ZoneVector<ExpressionTypeEntry>* dst);
void Run();
@@ -31,6 +34,7 @@
void VisitExpression(Expression* expression);
private:
+ const AstTypeBounds* bounds_;
ZoneVector<ExpressionTypeEntry>* result_;
};
} // namespace internal
diff --git a/test/cctest/heap/test-compaction.cc b/test/cctest/heap/test-compaction.cc
index 0feee5f..b787780 100644
--- a/test/cctest/heap/test-compaction.cc
+++ b/test/cctest/heap/test-compaction.cc
@@ -50,6 +50,7 @@
heap->set_force_oom(true);
heap->CollectAllGarbage();
+ heap->mark_compact_collector()->EnsureSweepingCompleted();
// Check that all handles still point to the same page, i.e., compaction
// has been aborted on the page.
@@ -108,6 +109,7 @@
heap->set_force_oom(true);
heap->CollectAllGarbage();
+ heap->mark_compact_collector()->EnsureSweepingCompleted();
bool migration_aborted = false;
for (Handle<FixedArray> object : compaction_page_handles) {
@@ -190,6 +192,7 @@
heap->set_force_oom(true);
heap->CollectAllGarbage();
+ heap->mark_compact_collector()->EnsureSweepingCompleted();
// The following check makes sure that we compacted "some" objects, while
// leaving others in place.
@@ -283,6 +286,7 @@
heap->set_force_oom(true);
heap->CollectAllGarbage();
+ heap->mark_compact_collector()->EnsureSweepingCompleted();
// The following check makes sure that we compacted "some" objects, while
// leaving others in place.
diff --git a/test/cctest/heap/test-heap.cc b/test/cctest/heap/test-heap.cc
index 424e987..ef4b217 100644
--- a/test/cctest/heap/test-heap.cc
+++ b/test/cctest/heap/test-heap.cc
@@ -31,6 +31,7 @@
#include "src/compilation-cache.h"
#include "src/context-measure.h"
#include "src/deoptimizer.h"
+#include "src/elements.h"
#include "src/execution.h"
#include "src/factory.h"
#include "src/field-type.h"
@@ -577,7 +578,7 @@
static bool WeakPointerCleared = false;
static void TestWeakGlobalHandleCallback(
- const v8::WeakCallbackData<v8::Value, void>& data) {
+ const v8::WeakCallbackInfo<void>& data) {
std::pair<v8::Persistent<v8::Value>*, int>* p =
reinterpret_cast<std::pair<v8::Persistent<v8::Value>*, int>*>(
data.GetParameter());
@@ -610,9 +611,9 @@
}
std::pair<Handle<Object>*, int> handle_and_id(&h2, 1234);
- GlobalHandles::MakeWeak(h2.location(),
- reinterpret_cast<void*>(&handle_and_id),
- &TestWeakGlobalHandleCallback);
+ GlobalHandles::MakeWeak(
+ h2.location(), reinterpret_cast<void*>(&handle_and_id),
+ &TestWeakGlobalHandleCallback, v8::WeakCallbackType::kParameter);
// Scavenge treats weak pointers as normal roots.
heap->CollectGarbage(NEW_SPACE);
@@ -657,9 +658,9 @@
CHECK(!heap->InNewSpace(*h1) && !heap->InNewSpace(*h2));
std::pair<Handle<Object>*, int> handle_and_id(&h2, 1234);
- GlobalHandles::MakeWeak(h2.location(),
- reinterpret_cast<void*>(&handle_and_id),
- &TestWeakGlobalHandleCallback);
+ GlobalHandles::MakeWeak(
+ h2.location(), reinterpret_cast<void*>(&handle_and_id),
+ &TestWeakGlobalHandleCallback, v8::WeakCallbackType::kParameter);
CHECK(!GlobalHandles::IsNearDeath(h1.location()));
CHECK(!GlobalHandles::IsNearDeath(h2.location()));
@@ -695,9 +696,9 @@
}
std::pair<Handle<Object>*, int> handle_and_id(&h, 1234);
- GlobalHandles::MakeWeak(h.location(),
- reinterpret_cast<void*>(&handle_and_id),
- &TestWeakGlobalHandleCallback);
+ GlobalHandles::MakeWeak(h.location(), reinterpret_cast<void*>(&handle_and_id),
+ &TestWeakGlobalHandleCallback,
+ v8::WeakCallbackType::kParameter);
// Scanvenge does not recognize weak reference.
heap->CollectGarbage(NEW_SPACE);
@@ -1546,10 +1547,7 @@
Handle<Object> g_value =
Object::GetProperty(isolate->global_object(), g_name).ToHandleChecked();
Handle<JSFunction> g_function = Handle<JSFunction>::cast(g_value);
- // TODO(mvstanton): change to check that g is *not* compiled when optimized
- // cache
- // map lookup moves to the compile lazy builtin.
- CHECK(g_function->is_compiled());
+ CHECK(!g_function->is_compiled());
SimulateIncrementalMarking(heap);
CompileRun("%OptimizeFunctionOnNextCall(f); f();");
@@ -1590,25 +1588,11 @@
CompileRun(raw_source);
}
- // On first compilation, only a hash is inserted in the code cache. We can't
- // find that value.
+ // The script should be in the cache now.
MaybeHandle<SharedFunctionInfo> info = compilation_cache->LookupScript(
source, Handle<Object>(), 0, 0,
v8::ScriptOriginOptions(false, true, false), native_context,
language_mode);
- CHECK(info.is_null());
-
- {
- v8::HandleScope scope(CcTest::isolate());
- CompileRun(raw_source);
- }
-
- // On second compilation, the hash is replaced by a real cache entry mapping
- // the source to the shared function info containing the code.
- info = compilation_cache->LookupScript(
- source, Handle<Object>(), 0, 0,
- v8::ScriptOriginOptions(false, true, false), native_context,
- language_mode);
CHECK(!info.is_null());
// Check that the code cache entry survives at least on GC.
@@ -1640,36 +1624,6 @@
v8::ScriptOriginOptions(false, true, false), native_context,
language_mode);
CHECK(info.is_null());
-
- {
- v8::HandleScope scope(CcTest::isolate());
- CompileRun(raw_source);
- }
-
- // On first compilation, only a hash is inserted in the code cache. We can't
- // find that value.
- info = compilation_cache->LookupScript(
- source, Handle<Object>(), 0, 0,
- v8::ScriptOriginOptions(false, true, false), native_context,
- language_mode);
- CHECK(info.is_null());
-
- for (int i = 0; i < CompilationCacheTable::kHashGenerations; i++) {
- compilation_cache->MarkCompactPrologue();
- }
-
- {
- v8::HandleScope scope(CcTest::isolate());
- CompileRun(raw_source);
- }
-
- // If we aged the cache before caching the script, ensure that we didn't cache
- // on next compilation.
- info = compilation_cache->LookupScript(
- source, Handle<Object>(), 0, 0,
- v8::ScriptOriginOptions(false, true, false), native_context,
- language_mode);
- CHECK(info.is_null());
}
@@ -1692,7 +1646,7 @@
Object* object = CcTest::heap()->native_contexts_list();
while (!object->IsUndefined()) {
count++;
- object = Context::cast(object)->get(Context::NEXT_CONTEXT_LINK);
+ object = Context::cast(object)->next_context_link();
}
return count;
}
@@ -1830,8 +1784,7 @@
count++;
if (count == n) heap->CollectAllGarbage();
object =
- Handle<Object>(Context::cast(*object)->get(Context::NEXT_CONTEXT_LINK),
- isolate);
+ Handle<Object>(Context::cast(*object)->next_context_link(), isolate);
}
return count;
}
@@ -2296,16 +2249,20 @@
// on the heap.
if (size_of_objects_1 > size_of_objects_2) {
intptr_t delta = size_of_objects_1 - size_of_objects_2;
- PrintF("Heap::SizeOfObjects: %" V8_PTR_PREFIX "d, "
- "Iterator: %" V8_PTR_PREFIX "d, "
- "delta: %" V8_PTR_PREFIX "d\n",
+ PrintF("Heap::SizeOfObjects: %" V8PRIdPTR
+ ", "
+ "Iterator: %" V8PRIdPTR
+ ", "
+ "delta: %" V8PRIdPTR "\n",
size_of_objects_1, size_of_objects_2, delta);
CHECK_GT(size_of_objects_1 / 20, delta);
} else {
intptr_t delta = size_of_objects_2 - size_of_objects_1;
- PrintF("Heap::SizeOfObjects: %" V8_PTR_PREFIX "d, "
- "Iterator: %" V8_PTR_PREFIX "d, "
- "delta: %" V8_PTR_PREFIX "d\n",
+ PrintF("Heap::SizeOfObjects: %" V8PRIdPTR
+ ", "
+ "Iterator: %" V8PRIdPTR
+ ", "
+ "delta: %" V8PRIdPTR "\n",
size_of_objects_1, size_of_objects_2, delta);
CHECK_GT(size_of_objects_2 / 20, delta);
}
@@ -2657,6 +2614,14 @@
CcTest::heap()->CollectGarbage(OLD_SPACE);
}
+namespace {
+
+int GetProfilerTicks(SharedFunctionInfo* shared) {
+ return FLAG_ignition ? shared->profiler_ticks()
+ : shared->code()->profiler_ticks();
+}
+
+} // namespace
TEST(ResetSharedFunctionInfoCountersDuringIncrementalMarking) {
i::FLAG_stress_compaction = false;
@@ -2687,16 +2652,18 @@
CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
CHECK(f->IsOptimized());
- IncrementalMarking* marking = CcTest::heap()->incremental_marking();
- marking->Stop();
+ // Make sure incremental marking it not running.
+ CcTest::heap()->incremental_marking()->Stop();
+
CcTest::heap()->StartIncrementalMarking();
// The following calls will increment CcTest::heap()->global_ic_age().
CcTest::isolate()->ContextDisposedNotification();
SimulateIncrementalMarking(CcTest::heap());
CcTest::heap()->CollectAllGarbage();
+
CHECK_EQ(CcTest::heap()->global_ic_age(), f->shared()->ic_age());
CHECK_EQ(0, f->shared()->opt_count());
- CHECK_EQ(0, f->shared()->code()->profiler_ticks());
+ CHECK_EQ(0, GetProfilerTicks(f->shared()));
}
@@ -2727,9 +2694,9 @@
i::Handle<JSFunction> f = i::Handle<JSFunction>::cast(
v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
-
CHECK(f->IsOptimized());
+ // Make sure incremental marking it not running.
CcTest::heap()->incremental_marking()->Stop();
// The following two calls will increment CcTest::heap()->global_ic_age().
@@ -2738,7 +2705,7 @@
CHECK_EQ(CcTest::heap()->global_ic_age(), f->shared()->ic_age());
CHECK_EQ(0, f->shared()->opt_count());
- CHECK_EQ(0, f->shared()->code()->profiler_ticks());
+ CHECK_EQ(0, GetProfilerTicks(f->shared()));
}
@@ -3557,6 +3524,8 @@
// Concurrent sweeping adds non determinism, depending on when memory is
// available for further reuse.
i::FLAG_concurrent_sweeping = false;
+ // Fast evacuation of pages may result in a different page count in old space.
+ i::FLAG_page_promotion = false;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
Factory* factory = isolate->factory();
@@ -5547,19 +5516,21 @@
isolate->Enter();
{
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ Heap* heap = i_isolate->heap();
HandleScope handle_scope(i_isolate);
- PagedSpace* old_space = i_isolate->heap()->old_space();
+ PagedSpace* old_space = heap->old_space();
const int kMaxObjects = 10000;
const int kFixedArrayLen = 512;
Handle<FixedArray> objects[kMaxObjects];
- for (int i = 0; (i < kMaxObjects) && old_space->CanExpand(Page::kPageSize);
+ for (int i = 0; (i < kMaxObjects) &&
+ heap->CanExpandOldGeneration(old_space->AreaSize());
i++) {
objects[i] = i_isolate->factory()->NewFixedArray(kFixedArrayLen, TENURED);
Page::FromAddress(objects[i]->address())
->SetFlag(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
}
SimulateFullSpace(old_space);
- i_isolate->heap()->CollectGarbage(OLD_SPACE);
+ heap->CollectGarbage(OLD_SPACE);
// If we get this far, we've successfully aborted compaction. Any further
// allocations might trigger OOM.
}
@@ -6304,6 +6275,28 @@
"check(g1, g2);");
}
+TEST(RemoveCodeFromSharedFunctionInfoButNotFromClosure) {
+ CcTest::InitializeVM();
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope scope(isolate);
+ v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
+ global->Set(isolate, "check", v8::FunctionTemplate::New(
+ isolate, CheckEqualSharedFunctionInfos));
+ global->Set(isolate, "remove",
+ v8::FunctionTemplate::New(isolate, RemoveCodeAndGC));
+ v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
+ v8::Context::Scope cscope(context);
+ CompileRun(
+ "function f() { return function g() {}; }"
+ "var g1 = f();"
+ "var g2 = f();"
+ "check(g1, g2);"
+ "g1();"
+ "g2();"
+ "remove(g1);"
+ "g2();"
+ "check(g1, g2);");
+}
TEST(OldGenerationAllocationThroughput) {
CcTest::InitializeVM();
@@ -6604,6 +6597,151 @@
heap->CollectGarbage(OLD_SPACE);
}
+UNINITIALIZED_TEST(PagePromotion) {
+ FLAG_page_promotion = true;
+ FLAG_page_promotion_threshold = 0; // %
+ i::FLAG_min_semi_space_size = 8 * (Page::kPageSize / MB);
+ // We cannot optimize for size as we require a new space with more than one
+ // page.
+ i::FLAG_optimize_for_size = false;
+ // Set max_semi_space_size because it could've been initialized by an
+ // implication of optimize_for_size.
+ i::FLAG_max_semi_space_size = i::FLAG_min_semi_space_size;
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Context::New(isolate)->Enter();
+ Heap* heap = i_isolate->heap();
+ std::vector<Handle<FixedArray>> handles;
+ SimulateFullSpace(heap->new_space(), &handles);
+ heap->CollectGarbage(NEW_SPACE);
+ CHECK_GT(handles.size(), 0u);
+ // First object in handle should be on the first page.
+ Handle<FixedArray> first_object = handles.front();
+ Page* first_page = Page::FromAddress(first_object->address());
+ // The age mark should not be on the first page.
+ CHECK(!first_page->ContainsLimit(heap->new_space()->age_mark()));
+ // To perform a sanity check on live bytes we need to mark the heap.
+ SimulateIncrementalMarking(heap, true);
+ // Sanity check that the page meets the requirements for promotion.
+ const int threshold_bytes =
+ FLAG_page_promotion_threshold * Page::kAllocatableMemory / 100;
+ CHECK_GE(first_page->LiveBytes(), threshold_bytes);
+
+ // Actual checks: The page is in new space first, but is moved to old space
+ // during a full GC.
+ CHECK(heap->new_space()->ContainsSlow(first_page->address()));
+ CHECK(!heap->old_space()->ContainsSlow(first_page->address()));
+ heap->CollectGarbage(OLD_SPACE);
+ CHECK(!heap->new_space()->ContainsSlow(first_page->address()));
+ CHECK(heap->old_space()->ContainsSlow(first_page->address()));
+ }
+}
+
+TEST(Regress598319) {
+ // This test ensures that no white objects can cross the progress bar of large
+ // objects during incremental marking. It checks this by using Shift() during
+ // incremental marking.
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Heap* heap = CcTest::heap();
+ Isolate* isolate = heap->isolate();
+
+ const int kNumberOfObjects = Page::kMaxRegularHeapObjectSize / kPointerSize;
+
+ struct Arr {
+ Arr(Isolate* isolate, int number_of_objects) {
+ root = isolate->factory()->NewFixedArray(1, TENURED);
+ {
+ // Temporary scope to avoid getting any other objects into the root set.
+ v8::HandleScope scope(CcTest::isolate());
+ Handle<FixedArray> tmp =
+ isolate->factory()->NewFixedArray(number_of_objects);
+ root->set(0, *tmp);
+ for (int i = 0; i < get()->length(); i++) {
+ tmp = isolate->factory()->NewFixedArray(100, TENURED);
+ get()->set(i, *tmp);
+ }
+ }
+ }
+
+ FixedArray* get() { return FixedArray::cast(root->get(0)); }
+
+ Handle<FixedArray> root;
+ } arr(isolate, kNumberOfObjects);
+
+ CHECK_EQ(arr.get()->length(), kNumberOfObjects);
+ CHECK(heap->lo_space()->Contains(arr.get()));
+ LargePage* page = heap->lo_space()->FindPage(arr.get()->address());
+ CHECK_NOT_NULL(page);
+
+ // GC to cleanup state
+ heap->CollectGarbage(OLD_SPACE);
+ MarkCompactCollector* collector = heap->mark_compact_collector();
+ if (collector->sweeping_in_progress()) {
+ collector->EnsureSweepingCompleted();
+ }
+
+ CHECK(heap->lo_space()->Contains(arr.get()));
+ CHECK(Marking::IsWhite(Marking::MarkBitFrom(arr.get())));
+ for (int i = 0; i < arr.get()->length(); i++) {
+ CHECK(Marking::IsWhite(
+ Marking::MarkBitFrom(HeapObject::cast(arr.get()->get(i)))));
+ }
+
+ // Start incremental marking.
+ IncrementalMarking* marking = heap->incremental_marking();
+ CHECK(marking->IsMarking() || marking->IsStopped());
+ if (marking->IsStopped()) {
+ heap->StartIncrementalMarking();
+ }
+ CHECK(marking->IsMarking());
+
+ // Check that we have not marked the interesting array during root scanning.
+ for (int i = 0; i < arr.get()->length(); i++) {
+ CHECK(Marking::IsWhite(
+ Marking::MarkBitFrom(HeapObject::cast(arr.get()->get(i)))));
+ }
+
+ // Now we search for a state where we are in incremental marking and have
+ // only partially marked the large object.
+ while (!marking->IsComplete()) {
+ marking->Step(i::KB, i::IncrementalMarking::NO_GC_VIA_STACK_GUARD);
+ if (page->IsFlagSet(Page::HAS_PROGRESS_BAR) && page->progress_bar() > 0) {
+ CHECK_NE(page->progress_bar(), arr.get()->Size());
+ {
+ // Shift by 1, effectively moving one white object across the progress
+ // bar, meaning that we will miss marking it.
+ v8::HandleScope scope(CcTest::isolate());
+ Handle<JSArray> js_array = isolate->factory()->NewJSArrayWithElements(
+ Handle<FixedArray>(arr.get()));
+ js_array->GetElementsAccessor()->Shift(js_array);
+ }
+ break;
+ }
+ }
+
+ // Finish marking with bigger steps to speed up test.
+ while (!marking->IsComplete()) {
+ marking->Step(10 * i::MB, i::IncrementalMarking::NO_GC_VIA_STACK_GUARD);
+ if (marking->IsReadyToOverApproximateWeakClosure()) {
+ marking->FinalizeIncrementally();
+ }
+ }
+ CHECK(marking->IsComplete());
+
+ // All objects need to be black after marking. If a white object crossed the
+ // progress bar, we would fail here.
+ for (int i = 0; i < arr.get()->length(); i++) {
+ CHECK(Marking::IsBlack(
+ Marking::MarkBitFrom(HeapObject::cast(arr.get()->get(i)))));
+ }
+}
+
TEST(Regress609761) {
CcTest::InitializeVM();
v8::HandleScope scope(CcTest::isolate());
diff --git a/test/cctest/heap/test-mark-compact.cc b/test/cctest/heap/test-mark-compact.cc
index cfcf149..2115f1c 100644
--- a/test/cctest/heap/test-mark-compact.cc
+++ b/test/cctest/heap/test-mark-compact.cc
@@ -236,8 +236,7 @@
static int NumberOfWeakCalls = 0;
-static void WeakPointerCallback(
- const v8::WeakCallbackData<v8::Value, void>& data) {
+static void WeakPointerCallback(const v8::WeakCallbackInfo<void>& data) {
std::pair<v8::Persistent<v8::Value>*, int>* p =
reinterpret_cast<std::pair<v8::Persistent<v8::Value>*, int>*>(
data.GetParameter());
@@ -262,17 +261,17 @@
Handle<Object> g1c1 =
global_handles->Create(heap->AllocateFixedArray(1).ToObjectChecked());
std::pair<Handle<Object>*, int> g1s1_and_id(&g1s1, 1234);
- GlobalHandles::MakeWeak(g1s1.location(),
- reinterpret_cast<void*>(&g1s1_and_id),
- &WeakPointerCallback);
+ GlobalHandles::MakeWeak(
+ g1s1.location(), reinterpret_cast<void*>(&g1s1_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
std::pair<Handle<Object>*, int> g1s2_and_id(&g1s2, 1234);
- GlobalHandles::MakeWeak(g1s2.location(),
- reinterpret_cast<void*>(&g1s2_and_id),
- &WeakPointerCallback);
+ GlobalHandles::MakeWeak(
+ g1s2.location(), reinterpret_cast<void*>(&g1s2_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
std::pair<Handle<Object>*, int> g1c1_and_id(&g1c1, 1234);
- GlobalHandles::MakeWeak(g1c1.location(),
- reinterpret_cast<void*>(&g1c1_and_id),
- &WeakPointerCallback);
+ GlobalHandles::MakeWeak(
+ g1c1.location(), reinterpret_cast<void*>(&g1c1_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
Handle<Object> g2s1 =
global_handles->Create(heap->AllocateFixedArray(1).ToObjectChecked());
@@ -281,17 +280,17 @@
Handle<Object> g2c1 =
global_handles->Create(heap->AllocateFixedArray(1).ToObjectChecked());
std::pair<Handle<Object>*, int> g2s1_and_id(&g2s1, 1234);
- GlobalHandles::MakeWeak(g2s1.location(),
- reinterpret_cast<void*>(&g2s1_and_id),
- &WeakPointerCallback);
+ GlobalHandles::MakeWeak(
+ g2s1.location(), reinterpret_cast<void*>(&g2s1_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
std::pair<Handle<Object>*, int> g2s2_and_id(&g2s2, 1234);
- GlobalHandles::MakeWeak(g2s2.location(),
- reinterpret_cast<void*>(&g2s2_and_id),
- &WeakPointerCallback);
+ GlobalHandles::MakeWeak(
+ g2s2.location(), reinterpret_cast<void*>(&g2s2_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
std::pair<Handle<Object>*, int> g2c1_and_id(&g2c1, 1234);
- GlobalHandles::MakeWeak(g2c1.location(),
- reinterpret_cast<void*>(&g2c1_and_id),
- &WeakPointerCallback);
+ GlobalHandles::MakeWeak(
+ g2c1.location(), reinterpret_cast<void*>(&g2c1_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
Handle<Object> root = global_handles->Create(*g1s1); // make a root.
@@ -317,9 +316,9 @@
// Weaken the root.
std::pair<Handle<Object>*, int> root_and_id(&root, 1234);
- GlobalHandles::MakeWeak(root.location(),
- reinterpret_cast<void*>(&root_and_id),
- &WeakPointerCallback);
+ GlobalHandles::MakeWeak(
+ root.location(), reinterpret_cast<void*>(&root_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
// But make children strong roots---all the objects (except for children)
// should be collectable now.
global_handles->ClearWeakness(g1c1.location());
@@ -343,12 +342,12 @@
CHECK_EQ(5, NumberOfWeakCalls);
// And now make children weak again and collect them.
- GlobalHandles::MakeWeak(g1c1.location(),
- reinterpret_cast<void*>(&g1c1_and_id),
- &WeakPointerCallback);
- GlobalHandles::MakeWeak(g2c1.location(),
- reinterpret_cast<void*>(&g2c1_and_id),
- &WeakPointerCallback);
+ GlobalHandles::MakeWeak(
+ g1c1.location(), reinterpret_cast<void*>(&g1c1_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
+ GlobalHandles::MakeWeak(
+ g2c1.location(), reinterpret_cast<void*>(&g2c1_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
heap->CollectGarbage(OLD_SPACE);
CHECK_EQ(7, NumberOfWeakCalls);
diff --git a/test/cctest/heap/test-spaces.cc b/test/cctest/heap/test-spaces.cc
index a7cf161..da364c5 100644
--- a/test/cctest/heap/test-spaces.cc
+++ b/test/cctest/heap/test-spaces.cc
@@ -107,13 +107,12 @@
class TestMemoryAllocatorScope {
public:
TestMemoryAllocatorScope(Isolate* isolate, MemoryAllocator* allocator)
- : isolate_(isolate),
- old_allocator_(isolate->memory_allocator_) {
- isolate->memory_allocator_ = allocator;
+ : isolate_(isolate), old_allocator_(isolate->heap()->memory_allocator()) {
+ isolate->heap()->memory_allocator_ = allocator;
}
~TestMemoryAllocatorScope() {
- isolate_->memory_allocator_ = old_allocator_;
+ isolate_->heap()->memory_allocator_ = old_allocator_;
}
private:
@@ -129,12 +128,12 @@
public:
TestCodeRangeScope(Isolate* isolate, CodeRange* code_range)
: isolate_(isolate),
- old_code_range_(isolate->code_range_) {
- isolate->code_range_ = code_range;
+ old_code_range_(isolate->heap()->memory_allocator()->code_range()) {
+ isolate->heap()->memory_allocator()->code_range_ = code_range;
}
~TestCodeRangeScope() {
- isolate_->code_range_ = old_code_range_;
+ isolate_->heap()->memory_allocator()->code_range_ = old_code_range_;
}
private:
@@ -153,50 +152,49 @@
size_t second_commit_area_size,
Executability executable) {
MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
- CHECK(memory_allocator->SetUp(heap->MaxReserved(),
- heap->MaxExecutableSize()));
- TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
- TestCodeRangeScope test_code_range_scope(isolate, code_range);
+ CHECK(memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize(),
+ 0));
+ {
+ TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
+ TestCodeRangeScope test_code_range_scope(isolate, code_range);
- size_t header_size = (executable == EXECUTABLE)
- ? MemoryAllocator::CodePageGuardStartOffset()
- : MemoryChunk::kObjectStartOffset;
- size_t guard_size = (executable == EXECUTABLE)
- ? MemoryAllocator::CodePageGuardSize()
- : 0;
+ size_t header_size = (executable == EXECUTABLE)
+ ? MemoryAllocator::CodePageGuardStartOffset()
+ : MemoryChunk::kObjectStartOffset;
+ size_t guard_size =
+ (executable == EXECUTABLE) ? MemoryAllocator::CodePageGuardSize() : 0;
- MemoryChunk* memory_chunk = memory_allocator->AllocateChunk(reserve_area_size,
- commit_area_size,
- executable,
- NULL);
- size_t alignment = code_range != NULL && code_range->valid()
- ? MemoryChunk::kAlignment
- : base::OS::CommitPageSize();
- size_t reserved_size =
- ((executable == EXECUTABLE))
- ? RoundUp(header_size + guard_size + reserve_area_size + guard_size,
- alignment)
- : RoundUp(header_size + reserve_area_size,
- base::OS::CommitPageSize());
- CHECK(memory_chunk->size() == reserved_size);
- CHECK(memory_chunk->area_start() < memory_chunk->address() +
- memory_chunk->size());
- CHECK(memory_chunk->area_end() <= memory_chunk->address() +
- memory_chunk->size());
- CHECK(static_cast<size_t>(memory_chunk->area_size()) == commit_area_size);
+ MemoryChunk* memory_chunk = memory_allocator->AllocateChunk(
+ reserve_area_size, commit_area_size, executable, NULL);
+ size_t alignment = code_range != NULL && code_range->valid()
+ ? MemoryChunk::kAlignment
+ : base::OS::CommitPageSize();
+ size_t reserved_size =
+ ((executable == EXECUTABLE))
+ ? RoundUp(header_size + guard_size + reserve_area_size + guard_size,
+ alignment)
+ : RoundUp(header_size + reserve_area_size,
+ base::OS::CommitPageSize());
+ CHECK(memory_chunk->size() == reserved_size);
+ CHECK(memory_chunk->area_start() <
+ memory_chunk->address() + memory_chunk->size());
+ CHECK(memory_chunk->area_end() <=
+ memory_chunk->address() + memory_chunk->size());
+ CHECK(static_cast<size_t>(memory_chunk->area_size()) == commit_area_size);
- Address area_start = memory_chunk->area_start();
+ Address area_start = memory_chunk->area_start();
- memory_chunk->CommitArea(second_commit_area_size);
- CHECK(area_start == memory_chunk->area_start());
- CHECK(memory_chunk->area_start() < memory_chunk->address() +
- memory_chunk->size());
- CHECK(memory_chunk->area_end() <= memory_chunk->address() +
- memory_chunk->size());
- CHECK(static_cast<size_t>(memory_chunk->area_size()) ==
- second_commit_area_size);
+ memory_chunk->CommitArea(second_commit_area_size);
+ CHECK(area_start == memory_chunk->area_start());
+ CHECK(memory_chunk->area_start() <
+ memory_chunk->address() + memory_chunk->size());
+ CHECK(memory_chunk->area_end() <=
+ memory_chunk->address() + memory_chunk->size());
+ CHECK(static_cast<size_t>(memory_chunk->area_size()) ==
+ second_commit_area_size);
- memory_allocator->Free(memory_chunk);
+ memory_allocator->Free<MemoryAllocator::kFull>(memory_chunk);
+ }
memory_allocator->TearDown();
delete memory_allocator;
}
@@ -207,8 +205,8 @@
Heap* heap = isolate->heap();
const int pageSize = Page::kPageSize;
MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
- CHECK(
- memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize()));
+ CHECK(memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize(),
+ 0));
TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
CodeRange* code_range = new CodeRange(isolate);
const size_t code_range_size = 4 * pageSize;
@@ -310,19 +308,19 @@
MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
CHECK(memory_allocator != nullptr);
- CHECK(memory_allocator->SetUp(heap->MaxReserved(),
- heap->MaxExecutableSize()));
+ CHECK(memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize(),
+ 0));
TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
{
int total_pages = 0;
OldSpace faked_space(heap, OLD_SPACE, NOT_EXECUTABLE);
- Page* first_page = memory_allocator->AllocatePage<Page>(
+ Page* first_page = memory_allocator->AllocatePage(
faked_space.AreaSize(), static_cast<PagedSpace*>(&faked_space),
NOT_EXECUTABLE);
first_page->InsertAfter(faked_space.anchor()->prev_page());
- CHECK(first_page->is_valid());
+ CHECK(Page::IsValid(first_page));
CHECK(first_page->next_page() == faked_space.anchor());
total_pages++;
@@ -331,10 +329,10 @@
}
// Again, we should get n or n - 1 pages.
- Page* other = memory_allocator->AllocatePage<Page>(
+ Page* other = memory_allocator->AllocatePage(
faked_space.AreaSize(), static_cast<PagedSpace*>(&faked_space),
NOT_EXECUTABLE);
- CHECK(other->is_valid());
+ CHECK(Page::IsValid(other));
total_pages++;
other->InsertAfter(first_page);
int page_count = 0;
@@ -345,7 +343,7 @@
CHECK(total_pages == page_count);
Page* second_page = first_page->next_page();
- CHECK(second_page->is_valid());
+ CHECK(Page::IsValid(second_page));
// OldSpace's destructor will tear down the space and free up all pages.
}
@@ -358,8 +356,8 @@
Isolate* isolate = CcTest::i_isolate();
Heap* heap = isolate->heap();
MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
- CHECK(memory_allocator->SetUp(heap->MaxReserved(),
- heap->MaxExecutableSize()));
+ CHECK(memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize(),
+ 0));
TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
NewSpace new_space(heap);
@@ -385,8 +383,8 @@
Isolate* isolate = CcTest::i_isolate();
Heap* heap = isolate->heap();
MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
- CHECK(memory_allocator->SetUp(heap->MaxReserved(),
- heap->MaxExecutableSize()));
+ CHECK(memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize(),
+ 0));
TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
OldSpace* s = new OldSpace(heap, OLD_SPACE, NOT_EXECUTABLE);
@@ -409,8 +407,8 @@
Heap* heap = isolate->heap();
MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
CHECK(memory_allocator != nullptr);
- CHECK(
- memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize()));
+ CHECK(memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize(),
+ 0));
TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
CompactionSpace* compaction_space =
diff --git a/test/cctest/heap/utils-inl.h b/test/cctest/heap/utils-inl.h
index 56033c1..0e943b4 100644
--- a/test/cctest/heap/utils-inl.h
+++ b/test/cctest/heap/utils-inl.h
@@ -63,37 +63,48 @@
// Helper function that simulates a full new-space in the heap.
-static inline bool FillUpOnePage(v8::internal::NewSpace* space) {
+static inline bool FillUpOnePage(
+ v8::internal::NewSpace* space,
+ std::vector<Handle<FixedArray>>* out_handles = nullptr) {
space->DisableInlineAllocationSteps();
int space_remaining = static_cast<int>(*space->allocation_limit_address() -
*space->allocation_top_address());
if (space_remaining == 0) return false;
- CreatePadding(space->heap(), space_remaining, i::NOT_TENURED);
+ std::vector<Handle<FixedArray>> handles =
+ CreatePadding(space->heap(), space_remaining, i::NOT_TENURED);
+ if (out_handles != nullptr)
+ out_handles->insert(out_handles->end(), handles.begin(), handles.end());
return true;
}
// Helper function that simulates a fill new-space in the heap.
-static inline void AllocateAllButNBytes(v8::internal::NewSpace* space,
- int extra_bytes) {
+static inline void AllocateAllButNBytes(
+ v8::internal::NewSpace* space, int extra_bytes,
+ std::vector<Handle<FixedArray>>* out_handles = nullptr) {
space->DisableInlineAllocationSteps();
int space_remaining = static_cast<int>(*space->allocation_limit_address() -
*space->allocation_top_address());
CHECK(space_remaining >= extra_bytes);
int new_linear_size = space_remaining - extra_bytes;
if (new_linear_size == 0) return;
- CreatePadding(space->heap(), new_linear_size, i::NOT_TENURED);
+ std::vector<Handle<FixedArray>> handles =
+ CreatePadding(space->heap(), new_linear_size, i::NOT_TENURED);
+ if (out_handles != nullptr)
+ out_handles->insert(out_handles->end(), handles.begin(), handles.end());
}
-
-static inline void FillCurrentPage(v8::internal::NewSpace* space) {
- AllocateAllButNBytes(space, 0);
+static inline void FillCurrentPage(
+ v8::internal::NewSpace* space,
+ std::vector<Handle<FixedArray>>* out_handles = nullptr) {
+ AllocateAllButNBytes(space, 0, out_handles);
}
-
-static inline void SimulateFullSpace(v8::internal::NewSpace* space) {
- FillCurrentPage(space);
- while (FillUpOnePage(space)) {
+static inline void SimulateFullSpace(
+ v8::internal::NewSpace* space,
+ std::vector<Handle<FixedArray>>* out_handles = nullptr) {
+ FillCurrentPage(space, out_handles);
+ while (FillUpOnePage(space, out_handles) || space->AddFreshPage()) {
}
}
diff --git a/test/cctest/interpreter/bytecode-expectations-printer.cc b/test/cctest/interpreter/bytecode-expectations-printer.cc
index bf43b95..b0f6236 100644
--- a/test/cctest/interpreter/bytecode-expectations-printer.cc
+++ b/test/cctest/interpreter/bytecode-expectations-printer.cc
@@ -4,6 +4,7 @@
#include "test/cctest/interpreter/bytecode-expectations-printer.h"
+#include <iomanip>
#include <iostream>
#include <vector>
@@ -19,6 +20,7 @@
#include "src/interpreter/bytecode-generator.h"
#include "src/interpreter/bytecodes.h"
#include "src/interpreter/interpreter.h"
+#include "src/interpreter/source-position-table.h"
namespace v8 {
namespace internal {
@@ -27,6 +29,7 @@
// static
const char* const BytecodeExpectationsPrinter::kDefaultTopFunctionName =
"__genbckexp_wrapper__";
+const char* const BytecodeExpectationsPrinter::kIndent = " ";
v8::Local<v8::String> BytecodeExpectationsPrinter::V8StringFromUTF8(
const char* data) const {
@@ -102,11 +105,11 @@
} // namespace
void BytecodeExpectationsPrinter::PrintBytecodeOperand(
- std::ostream& stream, const BytecodeArrayIterator& bytecode_iter,
+ std::ostream& stream, const BytecodeArrayIterator& bytecode_iterator,
const Bytecode& bytecode, int op_index, int parameter_count) const {
OperandType op_type = Bytecodes::GetOperandType(bytecode, op_index);
OperandSize op_size = Bytecodes::GetOperandSize(
- bytecode, op_index, bytecode_iter.current_operand_scale());
+ bytecode, op_index, bytecode_iterator.current_operand_scale());
const char* size_tag;
switch (op_size) {
@@ -125,7 +128,7 @@
}
if (Bytecodes::IsRegisterOperandType(op_type)) {
- Register register_value = bytecode_iter.GetRegisterOperand(op_index);
+ Register register_value = bytecode_iterator.GetRegisterOperand(op_index);
stream << 'R';
if (op_size != OperandSize::kByte) stream << size_tag;
if (register_value.is_new_target()) {
@@ -149,19 +152,19 @@
switch (op_type) {
case OperandType::kFlag8:
- stream << bytecode_iter.GetFlagOperand(op_index);
+ stream << bytecode_iterator.GetFlagOperand(op_index);
break;
case OperandType::kIdx:
- stream << bytecode_iter.GetIndexOperand(op_index);
+ stream << bytecode_iterator.GetIndexOperand(op_index);
break;
case OperandType::kImm:
- stream << bytecode_iter.GetImmediateOperand(op_index);
+ stream << bytecode_iterator.GetImmediateOperand(op_index);
break;
case OperandType::kRegCount:
- stream << bytecode_iter.GetRegisterCountOperand(op_index);
+ stream << bytecode_iterator.GetRegisterCountOperand(op_index);
break;
case OperandType::kRuntimeId: {
- uint32_t operand = bytecode_iter.GetRuntimeIdOperand(op_index);
+ uint32_t operand = bytecode_iterator.GetRuntimeIdOperand(op_index);
stream << "Runtime::k"
<< i::Runtime::FunctionForId(IndexToFunctionId(operand))->name;
break;
@@ -175,10 +178,10 @@
}
void BytecodeExpectationsPrinter::PrintBytecode(
- std::ostream& stream, const BytecodeArrayIterator& bytecode_iter,
+ std::ostream& stream, const BytecodeArrayIterator& bytecode_iterator,
int parameter_count) const {
- Bytecode bytecode = bytecode_iter.current_bytecode();
- OperandScale operand_scale = bytecode_iter.current_operand_scale();
+ Bytecode bytecode = bytecode_iterator.current_bytecode();
+ OperandScale operand_scale = bytecode_iterator.current_operand_scale();
if (Bytecodes::OperandScaleRequiresPrefixBytecode(operand_scale)) {
Bytecode prefix = Bytecodes::OperandScaleToPrefixBytecode(operand_scale);
stream << "B(" << Bytecodes::ToString(prefix) << "), ";
@@ -187,11 +190,30 @@
int operands_count = Bytecodes::NumberOfOperands(bytecode);
for (int op_index = 0; op_index < operands_count; ++op_index) {
stream << ", ";
- PrintBytecodeOperand(stream, bytecode_iter, bytecode, op_index,
+ PrintBytecodeOperand(stream, bytecode_iterator, bytecode, op_index,
parameter_count);
}
}
+void BytecodeExpectationsPrinter::PrintSourcePosition(
+ std::ostream& stream, SourcePositionTableIterator& source_iterator,
+ int bytecode_offset) const {
+ static const size_t kPositionWidth = 4;
+ if (!source_iterator.done() &&
+ source_iterator.bytecode_offset() == bytecode_offset) {
+ stream << "/* " << std::setw(kPositionWidth)
+ << source_iterator.source_position();
+ if (source_iterator.is_statement()) {
+ stream << " S> */ ";
+ } else {
+ stream << " E> */ ";
+ }
+ source_iterator.Advance();
+ } else {
+ stream << " " << std::setw(kPositionWidth) << ' ' << " ";
+ }
+}
+
void BytecodeExpectationsPrinter::PrintV8String(std::ostream& stream,
i::String* string) const {
stream << '"';
@@ -246,10 +268,15 @@
std::ostream& stream, i::Handle<i::BytecodeArray> bytecode_array) const {
stream << "bytecode array length: " << bytecode_array->length()
<< "\nbytecodes: [\n";
- BytecodeArrayIterator bytecode_iter(bytecode_array);
- for (; !bytecode_iter.done(); bytecode_iter.Advance()) {
- stream << " ";
- PrintBytecode(stream, bytecode_iter, bytecode_array->parameter_count());
+
+ SourcePositionTableIterator source_iterator(
+ bytecode_array->source_position_table());
+ BytecodeArrayIterator bytecode_iterator(bytecode_array);
+ for (; !bytecode_iterator.done(); bytecode_iterator.Advance()) {
+ stream << kIndent;
+ PrintSourcePosition(stream, source_iterator,
+ bytecode_iterator.current_offset());
+ PrintBytecode(stream, bytecode_iterator, bytecode_array->parameter_count());
stream << ",\n";
}
stream << "]\n";
@@ -261,7 +288,7 @@
int num_constants = constant_pool->length();
if (num_constants > 0) {
for (int i = 0; i < num_constants; ++i) {
- stream << " ";
+ stream << kIndent;
PrintConstant(stream, i::FixedArray::get(constant_pool, i, i_isolate()));
stream << ",\n";
}
@@ -275,7 +302,7 @@
std::stringstream body_stream(body);
std::string body_line;
while (std::getline(body_stream, body_line)) {
- stream << " ";
+ stream << kIndent;
PrintEscapedString(stream, body_line);
stream << '\n';
}
diff --git a/test/cctest/interpreter/bytecode-expectations-printer.h b/test/cctest/interpreter/bytecode-expectations-printer.h
index 0fcead5..32b8ff4 100644
--- a/test/cctest/interpreter/bytecode-expectations-printer.h
+++ b/test/cctest/interpreter/bytecode-expectations-printer.h
@@ -20,6 +20,7 @@
namespace interpreter {
class BytecodeArrayIterator;
+class SourcePositionTableIterator;
class BytecodeExpectationsPrinter final {
public:
@@ -65,12 +66,15 @@
void PrintEscapedString(std::ostream& stream, // NOLINT
const std::string& string) const;
void PrintBytecodeOperand(std::ostream& stream, // NOLINT
- const BytecodeArrayIterator& bytecode_iter,
+ const BytecodeArrayIterator& bytecode_iterator,
const Bytecode& bytecode, int op_index,
int parameter_count) const;
void PrintBytecode(std::ostream& stream, // NOLINT
- const BytecodeArrayIterator& bytecode_iter,
+ const BytecodeArrayIterator& bytecode_iterator,
int parameter_count) const;
+ void PrintSourcePosition(std::ostream& stream, // NOLINT
+ SourcePositionTableIterator& source_iterator,
+ int bytecode_offset) const;
void PrintV8String(std::ostream& stream, // NOLINT
i::String* string) const;
void PrintConstant(std::ostream& stream, // NOLINT
@@ -111,6 +115,7 @@
std::string test_function_name_;
static const char* const kDefaultTopFunctionName;
+ static const char* const kIndent;
};
} // namespace interpreter
diff --git a/test/cctest/interpreter/bytecode_expectations/ArrayLiterals.golden b/test/cctest/interpreter/bytecode_expectations/ArrayLiterals.golden
index 4c9753f..5dcb46b 100644
--- a/test/cctest/interpreter/bytecode_expectations/ArrayLiterals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ArrayLiterals.golden
@@ -15,9 +15,9 @@
parameter count: 1
bytecode array length: 6
bytecodes: [
- B(StackCheck),
- B(CreateArrayLiteral), U8(0), U8(0), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateArrayLiteral), U8(0), U8(0), U8(3),
+ /* 51 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -33,24 +33,24 @@
parameter count: 1
bytecode array length: 39
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(CreateArrayLiteral), U8(0), U8(0), U8(3),
- B(Star), R(2),
- B(LdaZero),
- B(Star), R(1),
- B(Ldar), R(0),
- B(KeyedStoreICSloppy), R(2), R(1), U8(1),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(3),
- B(LdaSmi), U8(1),
- B(Add), R(3),
- B(KeyedStoreICSloppy), R(2), R(1), U8(1),
- B(Ldar), R(2),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(CreateArrayLiteral), U8(0), U8(0), U8(3),
+ B(Star), R(2),
+ B(LdaZero),
+ B(Star), R(1),
+ /* 54 E> */ B(Ldar), R(0),
+ B(KeyedStoreICSloppy), R(2), R(1), U8(1),
+ B(LdaSmi), U8(1),
+ B(Star), R(1),
+ /* 57 E> */ B(Ldar), R(0),
+ B(Star), R(3),
+ B(LdaSmi), U8(1),
+ B(Add), R(3),
+ B(KeyedStoreICSloppy), R(2), R(1), U8(1),
+ B(Ldar), R(2),
+ /* 66 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -66,9 +66,9 @@
parameter count: 1
bytecode array length: 6
bytecodes: [
- B(StackCheck),
- B(CreateArrayLiteral), U8(0), U8(2), U8(2),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateArrayLiteral), U8(0), U8(2), U8(2),
+ /* 62 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -84,36 +84,36 @@
parameter count: 1
bytecode array length: 69
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(CreateArrayLiteral), U8(0), U8(2), U8(2),
- B(Star), R(2),
- B(LdaZero),
- B(Star), R(1),
- B(CreateArrayLiteral), U8(1), U8(0), U8(3),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(3),
- B(Ldar), R(0),
- B(KeyedStoreICSloppy), R(4), R(3), U8(1),
- B(Ldar), R(4),
- B(KeyedStoreICSloppy), R(2), R(1), U8(5),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(CreateArrayLiteral), U8(2), U8(1), U8(3),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(3),
- B(Ldar), R(0),
- B(Star), R(5),
- B(LdaSmi), U8(2),
- B(Add), R(5),
- B(KeyedStoreICSloppy), R(4), R(3), U8(3),
- B(Ldar), R(4),
- B(KeyedStoreICSloppy), R(2), R(1), U8(5),
- B(Ldar), R(2),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(CreateArrayLiteral), U8(0), U8(2), U8(2),
+ B(Star), R(2),
+ B(LdaZero),
+ B(Star), R(1),
+ B(CreateArrayLiteral), U8(1), U8(0), U8(3),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(3),
+ /* 56 E> */ B(Ldar), R(0),
+ B(KeyedStoreICSloppy), R(4), R(3), U8(1),
+ B(Ldar), R(4),
+ B(KeyedStoreICSloppy), R(2), R(1), U8(5),
+ B(LdaSmi), U8(1),
+ B(Star), R(1),
+ B(CreateArrayLiteral), U8(2), U8(1), U8(3),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(3),
+ /* 66 E> */ B(Ldar), R(0),
+ B(Star), R(5),
+ B(LdaSmi), U8(2),
+ B(Add), R(5),
+ B(KeyedStoreICSloppy), R(4), R(3), U8(3),
+ B(Ldar), R(4),
+ B(KeyedStoreICSloppy), R(2), R(1), U8(5),
+ B(Ldar), R(2),
+ /* 77 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/ArrayLiteralsWide.golden b/test/cctest/interpreter/bytecode_expectations/ArrayLiteralsWide.golden
index 2077b79..a852ad4 100644
--- a/test/cctest/interpreter/bytecode_expectations/ArrayLiteralsWide.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ArrayLiteralsWide.golden
@@ -272,521 +272,521 @@
parameter count: 1
bytecode array length: 1033
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(2),
- B(Star), R(0),
- B(LdaConstant), U8(3),
- B(Star), R(0),
- B(LdaConstant), U8(4),
- B(Star), R(0),
- B(LdaConstant), U8(5),
- B(Star), R(0),
- B(LdaConstant), U8(6),
- B(Star), R(0),
- B(LdaConstant), U8(7),
- B(Star), R(0),
- B(LdaConstant), U8(8),
- B(Star), R(0),
- B(LdaConstant), U8(9),
- B(Star), R(0),
- B(LdaConstant), U8(10),
- B(Star), R(0),
- B(LdaConstant), U8(11),
- B(Star), R(0),
- B(LdaConstant), U8(12),
- B(Star), R(0),
- B(LdaConstant), U8(13),
- B(Star), R(0),
- B(LdaConstant), U8(14),
- B(Star), R(0),
- B(LdaConstant), U8(15),
- B(Star), R(0),
- B(LdaConstant), U8(16),
- B(Star), R(0),
- B(LdaConstant), U8(17),
- B(Star), R(0),
- B(LdaConstant), U8(18),
- B(Star), R(0),
- B(LdaConstant), U8(19),
- B(Star), R(0),
- B(LdaConstant), U8(20),
- B(Star), R(0),
- B(LdaConstant), U8(21),
- B(Star), R(0),
- B(LdaConstant), U8(22),
- B(Star), R(0),
- B(LdaConstant), U8(23),
- B(Star), R(0),
- B(LdaConstant), U8(24),
- B(Star), R(0),
- B(LdaConstant), U8(25),
- B(Star), R(0),
- B(LdaConstant), U8(26),
- B(Star), R(0),
- B(LdaConstant), U8(27),
- B(Star), R(0),
- B(LdaConstant), U8(28),
- B(Star), R(0),
- B(LdaConstant), U8(29),
- B(Star), R(0),
- B(LdaConstant), U8(30),
- B(Star), R(0),
- B(LdaConstant), U8(31),
- B(Star), R(0),
- B(LdaConstant), U8(32),
- B(Star), R(0),
- B(LdaConstant), U8(33),
- B(Star), R(0),
- B(LdaConstant), U8(34),
- B(Star), R(0),
- B(LdaConstant), U8(35),
- B(Star), R(0),
- B(LdaConstant), U8(36),
- B(Star), R(0),
- B(LdaConstant), U8(37),
- B(Star), R(0),
- B(LdaConstant), U8(38),
- B(Star), R(0),
- B(LdaConstant), U8(39),
- B(Star), R(0),
- B(LdaConstant), U8(40),
- B(Star), R(0),
- B(LdaConstant), U8(41),
- B(Star), R(0),
- B(LdaConstant), U8(42),
- B(Star), R(0),
- B(LdaConstant), U8(43),
- B(Star), R(0),
- B(LdaConstant), U8(44),
- B(Star), R(0),
- B(LdaConstant), U8(45),
- B(Star), R(0),
- B(LdaConstant), U8(46),
- B(Star), R(0),
- B(LdaConstant), U8(47),
- B(Star), R(0),
- B(LdaConstant), U8(48),
- B(Star), R(0),
- B(LdaConstant), U8(49),
- B(Star), R(0),
- B(LdaConstant), U8(50),
- B(Star), R(0),
- B(LdaConstant), U8(51),
- B(Star), R(0),
- B(LdaConstant), U8(52),
- B(Star), R(0),
- B(LdaConstant), U8(53),
- B(Star), R(0),
- B(LdaConstant), U8(54),
- B(Star), R(0),
- B(LdaConstant), U8(55),
- B(Star), R(0),
- B(LdaConstant), U8(56),
- B(Star), R(0),
- B(LdaConstant), U8(57),
- B(Star), R(0),
- B(LdaConstant), U8(58),
- B(Star), R(0),
- B(LdaConstant), U8(59),
- B(Star), R(0),
- B(LdaConstant), U8(60),
- B(Star), R(0),
- B(LdaConstant), U8(61),
- B(Star), R(0),
- B(LdaConstant), U8(62),
- B(Star), R(0),
- B(LdaConstant), U8(63),
- B(Star), R(0),
- B(LdaConstant), U8(64),
- B(Star), R(0),
- B(LdaConstant), U8(65),
- B(Star), R(0),
- B(LdaConstant), U8(66),
- B(Star), R(0),
- B(LdaConstant), U8(67),
- B(Star), R(0),
- B(LdaConstant), U8(68),
- B(Star), R(0),
- B(LdaConstant), U8(69),
- B(Star), R(0),
- B(LdaConstant), U8(70),
- B(Star), R(0),
- B(LdaConstant), U8(71),
- B(Star), R(0),
- B(LdaConstant), U8(72),
- B(Star), R(0),
- B(LdaConstant), U8(73),
- B(Star), R(0),
- B(LdaConstant), U8(74),
- B(Star), R(0),
- B(LdaConstant), U8(75),
- B(Star), R(0),
- B(LdaConstant), U8(76),
- B(Star), R(0),
- B(LdaConstant), U8(77),
- B(Star), R(0),
- B(LdaConstant), U8(78),
- B(Star), R(0),
- B(LdaConstant), U8(79),
- B(Star), R(0),
- B(LdaConstant), U8(80),
- B(Star), R(0),
- B(LdaConstant), U8(81),
- B(Star), R(0),
- B(LdaConstant), U8(82),
- B(Star), R(0),
- B(LdaConstant), U8(83),
- B(Star), R(0),
- B(LdaConstant), U8(84),
- B(Star), R(0),
- B(LdaConstant), U8(85),
- B(Star), R(0),
- B(LdaConstant), U8(86),
- B(Star), R(0),
- B(LdaConstant), U8(87),
- B(Star), R(0),
- B(LdaConstant), U8(88),
- B(Star), R(0),
- B(LdaConstant), U8(89),
- B(Star), R(0),
- B(LdaConstant), U8(90),
- B(Star), R(0),
- B(LdaConstant), U8(91),
- B(Star), R(0),
- B(LdaConstant), U8(92),
- B(Star), R(0),
- B(LdaConstant), U8(93),
- B(Star), R(0),
- B(LdaConstant), U8(94),
- B(Star), R(0),
- B(LdaConstant), U8(95),
- B(Star), R(0),
- B(LdaConstant), U8(96),
- B(Star), R(0),
- B(LdaConstant), U8(97),
- B(Star), R(0),
- B(LdaConstant), U8(98),
- B(Star), R(0),
- B(LdaConstant), U8(99),
- B(Star), R(0),
- B(LdaConstant), U8(100),
- B(Star), R(0),
- B(LdaConstant), U8(101),
- B(Star), R(0),
- B(LdaConstant), U8(102),
- B(Star), R(0),
- B(LdaConstant), U8(103),
- B(Star), R(0),
- B(LdaConstant), U8(104),
- B(Star), R(0),
- B(LdaConstant), U8(105),
- B(Star), R(0),
- B(LdaConstant), U8(106),
- B(Star), R(0),
- B(LdaConstant), U8(107),
- B(Star), R(0),
- B(LdaConstant), U8(108),
- B(Star), R(0),
- B(LdaConstant), U8(109),
- B(Star), R(0),
- B(LdaConstant), U8(110),
- B(Star), R(0),
- B(LdaConstant), U8(111),
- B(Star), R(0),
- B(LdaConstant), U8(112),
- B(Star), R(0),
- B(LdaConstant), U8(113),
- B(Star), R(0),
- B(LdaConstant), U8(114),
- B(Star), R(0),
- B(LdaConstant), U8(115),
- B(Star), R(0),
- B(LdaConstant), U8(116),
- B(Star), R(0),
- B(LdaConstant), U8(117),
- B(Star), R(0),
- B(LdaConstant), U8(118),
- B(Star), R(0),
- B(LdaConstant), U8(119),
- B(Star), R(0),
- B(LdaConstant), U8(120),
- B(Star), R(0),
- B(LdaConstant), U8(121),
- B(Star), R(0),
- B(LdaConstant), U8(122),
- B(Star), R(0),
- B(LdaConstant), U8(123),
- B(Star), R(0),
- B(LdaConstant), U8(124),
- B(Star), R(0),
- B(LdaConstant), U8(125),
- B(Star), R(0),
- B(LdaConstant), U8(126),
- B(Star), R(0),
- B(LdaConstant), U8(127),
- B(Star), R(0),
- B(LdaConstant), U8(128),
- B(Star), R(0),
- B(LdaConstant), U8(129),
- B(Star), R(0),
- B(LdaConstant), U8(130),
- B(Star), R(0),
- B(LdaConstant), U8(131),
- B(Star), R(0),
- B(LdaConstant), U8(132),
- B(Star), R(0),
- B(LdaConstant), U8(133),
- B(Star), R(0),
- B(LdaConstant), U8(134),
- B(Star), R(0),
- B(LdaConstant), U8(135),
- B(Star), R(0),
- B(LdaConstant), U8(136),
- B(Star), R(0),
- B(LdaConstant), U8(137),
- B(Star), R(0),
- B(LdaConstant), U8(138),
- B(Star), R(0),
- B(LdaConstant), U8(139),
- B(Star), R(0),
- B(LdaConstant), U8(140),
- B(Star), R(0),
- B(LdaConstant), U8(141),
- B(Star), R(0),
- B(LdaConstant), U8(142),
- B(Star), R(0),
- B(LdaConstant), U8(143),
- B(Star), R(0),
- B(LdaConstant), U8(144),
- B(Star), R(0),
- B(LdaConstant), U8(145),
- B(Star), R(0),
- B(LdaConstant), U8(146),
- B(Star), R(0),
- B(LdaConstant), U8(147),
- B(Star), R(0),
- B(LdaConstant), U8(148),
- B(Star), R(0),
- B(LdaConstant), U8(149),
- B(Star), R(0),
- B(LdaConstant), U8(150),
- B(Star), R(0),
- B(LdaConstant), U8(151),
- B(Star), R(0),
- B(LdaConstant), U8(152),
- B(Star), R(0),
- B(LdaConstant), U8(153),
- B(Star), R(0),
- B(LdaConstant), U8(154),
- B(Star), R(0),
- B(LdaConstant), U8(155),
- B(Star), R(0),
- B(LdaConstant), U8(156),
- B(Star), R(0),
- B(LdaConstant), U8(157),
- B(Star), R(0),
- B(LdaConstant), U8(158),
- B(Star), R(0),
- B(LdaConstant), U8(159),
- B(Star), R(0),
- B(LdaConstant), U8(160),
- B(Star), R(0),
- B(LdaConstant), U8(161),
- B(Star), R(0),
- B(LdaConstant), U8(162),
- B(Star), R(0),
- B(LdaConstant), U8(163),
- B(Star), R(0),
- B(LdaConstant), U8(164),
- B(Star), R(0),
- B(LdaConstant), U8(165),
- B(Star), R(0),
- B(LdaConstant), U8(166),
- B(Star), R(0),
- B(LdaConstant), U8(167),
- B(Star), R(0),
- B(LdaConstant), U8(168),
- B(Star), R(0),
- B(LdaConstant), U8(169),
- B(Star), R(0),
- B(LdaConstant), U8(170),
- B(Star), R(0),
- B(LdaConstant), U8(171),
- B(Star), R(0),
- B(LdaConstant), U8(172),
- B(Star), R(0),
- B(LdaConstant), U8(173),
- B(Star), R(0),
- B(LdaConstant), U8(174),
- B(Star), R(0),
- B(LdaConstant), U8(175),
- B(Star), R(0),
- B(LdaConstant), U8(176),
- B(Star), R(0),
- B(LdaConstant), U8(177),
- B(Star), R(0),
- B(LdaConstant), U8(178),
- B(Star), R(0),
- B(LdaConstant), U8(179),
- B(Star), R(0),
- B(LdaConstant), U8(180),
- B(Star), R(0),
- B(LdaConstant), U8(181),
- B(Star), R(0),
- B(LdaConstant), U8(182),
- B(Star), R(0),
- B(LdaConstant), U8(183),
- B(Star), R(0),
- B(LdaConstant), U8(184),
- B(Star), R(0),
- B(LdaConstant), U8(185),
- B(Star), R(0),
- B(LdaConstant), U8(186),
- B(Star), R(0),
- B(LdaConstant), U8(187),
- B(Star), R(0),
- B(LdaConstant), U8(188),
- B(Star), R(0),
- B(LdaConstant), U8(189),
- B(Star), R(0),
- B(LdaConstant), U8(190),
- B(Star), R(0),
- B(LdaConstant), U8(191),
- B(Star), R(0),
- B(LdaConstant), U8(192),
- B(Star), R(0),
- B(LdaConstant), U8(193),
- B(Star), R(0),
- B(LdaConstant), U8(194),
- B(Star), R(0),
- B(LdaConstant), U8(195),
- B(Star), R(0),
- B(LdaConstant), U8(196),
- B(Star), R(0),
- B(LdaConstant), U8(197),
- B(Star), R(0),
- B(LdaConstant), U8(198),
- B(Star), R(0),
- B(LdaConstant), U8(199),
- B(Star), R(0),
- B(LdaConstant), U8(200),
- B(Star), R(0),
- B(LdaConstant), U8(201),
- B(Star), R(0),
- B(LdaConstant), U8(202),
- B(Star), R(0),
- B(LdaConstant), U8(203),
- B(Star), R(0),
- B(LdaConstant), U8(204),
- B(Star), R(0),
- B(LdaConstant), U8(205),
- B(Star), R(0),
- B(LdaConstant), U8(206),
- B(Star), R(0),
- B(LdaConstant), U8(207),
- B(Star), R(0),
- B(LdaConstant), U8(208),
- B(Star), R(0),
- B(LdaConstant), U8(209),
- B(Star), R(0),
- B(LdaConstant), U8(210),
- B(Star), R(0),
- B(LdaConstant), U8(211),
- B(Star), R(0),
- B(LdaConstant), U8(212),
- B(Star), R(0),
- B(LdaConstant), U8(213),
- B(Star), R(0),
- B(LdaConstant), U8(214),
- B(Star), R(0),
- B(LdaConstant), U8(215),
- B(Star), R(0),
- B(LdaConstant), U8(216),
- B(Star), R(0),
- B(LdaConstant), U8(217),
- B(Star), R(0),
- B(LdaConstant), U8(218),
- B(Star), R(0),
- B(LdaConstant), U8(219),
- B(Star), R(0),
- B(LdaConstant), U8(220),
- B(Star), R(0),
- B(LdaConstant), U8(221),
- B(Star), R(0),
- B(LdaConstant), U8(222),
- B(Star), R(0),
- B(LdaConstant), U8(223),
- B(Star), R(0),
- B(LdaConstant), U8(224),
- B(Star), R(0),
- B(LdaConstant), U8(225),
- B(Star), R(0),
- B(LdaConstant), U8(226),
- B(Star), R(0),
- B(LdaConstant), U8(227),
- B(Star), R(0),
- B(LdaConstant), U8(228),
- B(Star), R(0),
- B(LdaConstant), U8(229),
- B(Star), R(0),
- B(LdaConstant), U8(230),
- B(Star), R(0),
- B(LdaConstant), U8(231),
- B(Star), R(0),
- B(LdaConstant), U8(232),
- B(Star), R(0),
- B(LdaConstant), U8(233),
- B(Star), R(0),
- B(LdaConstant), U8(234),
- B(Star), R(0),
- B(LdaConstant), U8(235),
- B(Star), R(0),
- B(LdaConstant), U8(236),
- B(Star), R(0),
- B(LdaConstant), U8(237),
- B(Star), R(0),
- B(LdaConstant), U8(238),
- B(Star), R(0),
- B(LdaConstant), U8(239),
- B(Star), R(0),
- B(LdaConstant), U8(240),
- B(Star), R(0),
- B(LdaConstant), U8(241),
- B(Star), R(0),
- B(LdaConstant), U8(242),
- B(Star), R(0),
- B(LdaConstant), U8(243),
- B(Star), R(0),
- B(LdaConstant), U8(244),
- B(Star), R(0),
- B(LdaConstant), U8(245),
- B(Star), R(0),
- B(LdaConstant), U8(246),
- B(Star), R(0),
- B(LdaConstant), U8(247),
- B(Star), R(0),
- B(LdaConstant), U8(248),
- B(Star), R(0),
- B(LdaConstant), U8(249),
- B(Star), R(0),
- B(LdaConstant), U8(250),
- B(Star), R(0),
- B(LdaConstant), U8(251),
- B(Star), R(0),
- B(LdaConstant), U8(252),
- B(Star), R(0),
- B(LdaConstant), U8(253),
- B(Star), R(0),
- B(LdaConstant), U8(254),
- B(Star), R(0),
- B(LdaConstant), U8(255),
- B(Star), R(0),
- B(Wide), B(CreateArrayLiteral), U16(256), U16(0), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 41 S> */ B(LdaConstant), U8(0),
+ /* 43 E> */ B(Star), R(0),
+ /* 51 S> */ B(LdaConstant), U8(1),
+ /* 53 E> */ B(Star), R(0),
+ /* 61 S> */ B(LdaConstant), U8(2),
+ /* 63 E> */ B(Star), R(0),
+ /* 71 S> */ B(LdaConstant), U8(3),
+ /* 73 E> */ B(Star), R(0),
+ /* 81 S> */ B(LdaConstant), U8(4),
+ /* 83 E> */ B(Star), R(0),
+ /* 91 S> */ B(LdaConstant), U8(5),
+ /* 93 E> */ B(Star), R(0),
+ /* 101 S> */ B(LdaConstant), U8(6),
+ /* 103 E> */ B(Star), R(0),
+ /* 111 S> */ B(LdaConstant), U8(7),
+ /* 113 E> */ B(Star), R(0),
+ /* 121 S> */ B(LdaConstant), U8(8),
+ /* 123 E> */ B(Star), R(0),
+ /* 131 S> */ B(LdaConstant), U8(9),
+ /* 133 E> */ B(Star), R(0),
+ /* 141 S> */ B(LdaConstant), U8(10),
+ /* 143 E> */ B(Star), R(0),
+ /* 151 S> */ B(LdaConstant), U8(11),
+ /* 153 E> */ B(Star), R(0),
+ /* 161 S> */ B(LdaConstant), U8(12),
+ /* 163 E> */ B(Star), R(0),
+ /* 171 S> */ B(LdaConstant), U8(13),
+ /* 173 E> */ B(Star), R(0),
+ /* 181 S> */ B(LdaConstant), U8(14),
+ /* 183 E> */ B(Star), R(0),
+ /* 191 S> */ B(LdaConstant), U8(15),
+ /* 193 E> */ B(Star), R(0),
+ /* 201 S> */ B(LdaConstant), U8(16),
+ /* 203 E> */ B(Star), R(0),
+ /* 211 S> */ B(LdaConstant), U8(17),
+ /* 213 E> */ B(Star), R(0),
+ /* 221 S> */ B(LdaConstant), U8(18),
+ /* 223 E> */ B(Star), R(0),
+ /* 231 S> */ B(LdaConstant), U8(19),
+ /* 233 E> */ B(Star), R(0),
+ /* 241 S> */ B(LdaConstant), U8(20),
+ /* 243 E> */ B(Star), R(0),
+ /* 251 S> */ B(LdaConstant), U8(21),
+ /* 253 E> */ B(Star), R(0),
+ /* 261 S> */ B(LdaConstant), U8(22),
+ /* 263 E> */ B(Star), R(0),
+ /* 271 S> */ B(LdaConstant), U8(23),
+ /* 273 E> */ B(Star), R(0),
+ /* 281 S> */ B(LdaConstant), U8(24),
+ /* 283 E> */ B(Star), R(0),
+ /* 291 S> */ B(LdaConstant), U8(25),
+ /* 293 E> */ B(Star), R(0),
+ /* 301 S> */ B(LdaConstant), U8(26),
+ /* 303 E> */ B(Star), R(0),
+ /* 311 S> */ B(LdaConstant), U8(27),
+ /* 313 E> */ B(Star), R(0),
+ /* 321 S> */ B(LdaConstant), U8(28),
+ /* 323 E> */ B(Star), R(0),
+ /* 331 S> */ B(LdaConstant), U8(29),
+ /* 333 E> */ B(Star), R(0),
+ /* 341 S> */ B(LdaConstant), U8(30),
+ /* 343 E> */ B(Star), R(0),
+ /* 351 S> */ B(LdaConstant), U8(31),
+ /* 353 E> */ B(Star), R(0),
+ /* 361 S> */ B(LdaConstant), U8(32),
+ /* 363 E> */ B(Star), R(0),
+ /* 371 S> */ B(LdaConstant), U8(33),
+ /* 373 E> */ B(Star), R(0),
+ /* 381 S> */ B(LdaConstant), U8(34),
+ /* 383 E> */ B(Star), R(0),
+ /* 391 S> */ B(LdaConstant), U8(35),
+ /* 393 E> */ B(Star), R(0),
+ /* 401 S> */ B(LdaConstant), U8(36),
+ /* 403 E> */ B(Star), R(0),
+ /* 411 S> */ B(LdaConstant), U8(37),
+ /* 413 E> */ B(Star), R(0),
+ /* 421 S> */ B(LdaConstant), U8(38),
+ /* 423 E> */ B(Star), R(0),
+ /* 431 S> */ B(LdaConstant), U8(39),
+ /* 433 E> */ B(Star), R(0),
+ /* 441 S> */ B(LdaConstant), U8(40),
+ /* 443 E> */ B(Star), R(0),
+ /* 451 S> */ B(LdaConstant), U8(41),
+ /* 453 E> */ B(Star), R(0),
+ /* 461 S> */ B(LdaConstant), U8(42),
+ /* 463 E> */ B(Star), R(0),
+ /* 471 S> */ B(LdaConstant), U8(43),
+ /* 473 E> */ B(Star), R(0),
+ /* 481 S> */ B(LdaConstant), U8(44),
+ /* 483 E> */ B(Star), R(0),
+ /* 491 S> */ B(LdaConstant), U8(45),
+ /* 493 E> */ B(Star), R(0),
+ /* 501 S> */ B(LdaConstant), U8(46),
+ /* 503 E> */ B(Star), R(0),
+ /* 511 S> */ B(LdaConstant), U8(47),
+ /* 513 E> */ B(Star), R(0),
+ /* 521 S> */ B(LdaConstant), U8(48),
+ /* 523 E> */ B(Star), R(0),
+ /* 531 S> */ B(LdaConstant), U8(49),
+ /* 533 E> */ B(Star), R(0),
+ /* 541 S> */ B(LdaConstant), U8(50),
+ /* 543 E> */ B(Star), R(0),
+ /* 551 S> */ B(LdaConstant), U8(51),
+ /* 553 E> */ B(Star), R(0),
+ /* 561 S> */ B(LdaConstant), U8(52),
+ /* 563 E> */ B(Star), R(0),
+ /* 571 S> */ B(LdaConstant), U8(53),
+ /* 573 E> */ B(Star), R(0),
+ /* 581 S> */ B(LdaConstant), U8(54),
+ /* 583 E> */ B(Star), R(0),
+ /* 591 S> */ B(LdaConstant), U8(55),
+ /* 593 E> */ B(Star), R(0),
+ /* 601 S> */ B(LdaConstant), U8(56),
+ /* 603 E> */ B(Star), R(0),
+ /* 611 S> */ B(LdaConstant), U8(57),
+ /* 613 E> */ B(Star), R(0),
+ /* 621 S> */ B(LdaConstant), U8(58),
+ /* 623 E> */ B(Star), R(0),
+ /* 631 S> */ B(LdaConstant), U8(59),
+ /* 633 E> */ B(Star), R(0),
+ /* 641 S> */ B(LdaConstant), U8(60),
+ /* 643 E> */ B(Star), R(0),
+ /* 651 S> */ B(LdaConstant), U8(61),
+ /* 653 E> */ B(Star), R(0),
+ /* 661 S> */ B(LdaConstant), U8(62),
+ /* 663 E> */ B(Star), R(0),
+ /* 671 S> */ B(LdaConstant), U8(63),
+ /* 673 E> */ B(Star), R(0),
+ /* 681 S> */ B(LdaConstant), U8(64),
+ /* 683 E> */ B(Star), R(0),
+ /* 691 S> */ B(LdaConstant), U8(65),
+ /* 693 E> */ B(Star), R(0),
+ /* 701 S> */ B(LdaConstant), U8(66),
+ /* 703 E> */ B(Star), R(0),
+ /* 711 S> */ B(LdaConstant), U8(67),
+ /* 713 E> */ B(Star), R(0),
+ /* 721 S> */ B(LdaConstant), U8(68),
+ /* 723 E> */ B(Star), R(0),
+ /* 731 S> */ B(LdaConstant), U8(69),
+ /* 733 E> */ B(Star), R(0),
+ /* 741 S> */ B(LdaConstant), U8(70),
+ /* 743 E> */ B(Star), R(0),
+ /* 751 S> */ B(LdaConstant), U8(71),
+ /* 753 E> */ B(Star), R(0),
+ /* 761 S> */ B(LdaConstant), U8(72),
+ /* 763 E> */ B(Star), R(0),
+ /* 771 S> */ B(LdaConstant), U8(73),
+ /* 773 E> */ B(Star), R(0),
+ /* 781 S> */ B(LdaConstant), U8(74),
+ /* 783 E> */ B(Star), R(0),
+ /* 791 S> */ B(LdaConstant), U8(75),
+ /* 793 E> */ B(Star), R(0),
+ /* 801 S> */ B(LdaConstant), U8(76),
+ /* 803 E> */ B(Star), R(0),
+ /* 811 S> */ B(LdaConstant), U8(77),
+ /* 813 E> */ B(Star), R(0),
+ /* 821 S> */ B(LdaConstant), U8(78),
+ /* 823 E> */ B(Star), R(0),
+ /* 831 S> */ B(LdaConstant), U8(79),
+ /* 833 E> */ B(Star), R(0),
+ /* 841 S> */ B(LdaConstant), U8(80),
+ /* 843 E> */ B(Star), R(0),
+ /* 851 S> */ B(LdaConstant), U8(81),
+ /* 853 E> */ B(Star), R(0),
+ /* 861 S> */ B(LdaConstant), U8(82),
+ /* 863 E> */ B(Star), R(0),
+ /* 871 S> */ B(LdaConstant), U8(83),
+ /* 873 E> */ B(Star), R(0),
+ /* 881 S> */ B(LdaConstant), U8(84),
+ /* 883 E> */ B(Star), R(0),
+ /* 891 S> */ B(LdaConstant), U8(85),
+ /* 893 E> */ B(Star), R(0),
+ /* 901 S> */ B(LdaConstant), U8(86),
+ /* 903 E> */ B(Star), R(0),
+ /* 911 S> */ B(LdaConstant), U8(87),
+ /* 913 E> */ B(Star), R(0),
+ /* 921 S> */ B(LdaConstant), U8(88),
+ /* 923 E> */ B(Star), R(0),
+ /* 931 S> */ B(LdaConstant), U8(89),
+ /* 933 E> */ B(Star), R(0),
+ /* 941 S> */ B(LdaConstant), U8(90),
+ /* 943 E> */ B(Star), R(0),
+ /* 951 S> */ B(LdaConstant), U8(91),
+ /* 953 E> */ B(Star), R(0),
+ /* 961 S> */ B(LdaConstant), U8(92),
+ /* 963 E> */ B(Star), R(0),
+ /* 971 S> */ B(LdaConstant), U8(93),
+ /* 973 E> */ B(Star), R(0),
+ /* 981 S> */ B(LdaConstant), U8(94),
+ /* 983 E> */ B(Star), R(0),
+ /* 991 S> */ B(LdaConstant), U8(95),
+ /* 993 E> */ B(Star), R(0),
+ /* 1001 S> */ B(LdaConstant), U8(96),
+ /* 1003 E> */ B(Star), R(0),
+ /* 1011 S> */ B(LdaConstant), U8(97),
+ /* 1013 E> */ B(Star), R(0),
+ /* 1021 S> */ B(LdaConstant), U8(98),
+ /* 1023 E> */ B(Star), R(0),
+ /* 1031 S> */ B(LdaConstant), U8(99),
+ /* 1033 E> */ B(Star), R(0),
+ /* 1041 S> */ B(LdaConstant), U8(100),
+ /* 1043 E> */ B(Star), R(0),
+ /* 1051 S> */ B(LdaConstant), U8(101),
+ /* 1053 E> */ B(Star), R(0),
+ /* 1061 S> */ B(LdaConstant), U8(102),
+ /* 1063 E> */ B(Star), R(0),
+ /* 1071 S> */ B(LdaConstant), U8(103),
+ /* 1073 E> */ B(Star), R(0),
+ /* 1081 S> */ B(LdaConstant), U8(104),
+ /* 1083 E> */ B(Star), R(0),
+ /* 1091 S> */ B(LdaConstant), U8(105),
+ /* 1093 E> */ B(Star), R(0),
+ /* 1101 S> */ B(LdaConstant), U8(106),
+ /* 1103 E> */ B(Star), R(0),
+ /* 1111 S> */ B(LdaConstant), U8(107),
+ /* 1113 E> */ B(Star), R(0),
+ /* 1121 S> */ B(LdaConstant), U8(108),
+ /* 1123 E> */ B(Star), R(0),
+ /* 1131 S> */ B(LdaConstant), U8(109),
+ /* 1133 E> */ B(Star), R(0),
+ /* 1141 S> */ B(LdaConstant), U8(110),
+ /* 1143 E> */ B(Star), R(0),
+ /* 1151 S> */ B(LdaConstant), U8(111),
+ /* 1153 E> */ B(Star), R(0),
+ /* 1161 S> */ B(LdaConstant), U8(112),
+ /* 1163 E> */ B(Star), R(0),
+ /* 1171 S> */ B(LdaConstant), U8(113),
+ /* 1173 E> */ B(Star), R(0),
+ /* 1181 S> */ B(LdaConstant), U8(114),
+ /* 1183 E> */ B(Star), R(0),
+ /* 1191 S> */ B(LdaConstant), U8(115),
+ /* 1193 E> */ B(Star), R(0),
+ /* 1201 S> */ B(LdaConstant), U8(116),
+ /* 1203 E> */ B(Star), R(0),
+ /* 1211 S> */ B(LdaConstant), U8(117),
+ /* 1213 E> */ B(Star), R(0),
+ /* 1221 S> */ B(LdaConstant), U8(118),
+ /* 1223 E> */ B(Star), R(0),
+ /* 1231 S> */ B(LdaConstant), U8(119),
+ /* 1233 E> */ B(Star), R(0),
+ /* 1241 S> */ B(LdaConstant), U8(120),
+ /* 1243 E> */ B(Star), R(0),
+ /* 1251 S> */ B(LdaConstant), U8(121),
+ /* 1253 E> */ B(Star), R(0),
+ /* 1261 S> */ B(LdaConstant), U8(122),
+ /* 1263 E> */ B(Star), R(0),
+ /* 1271 S> */ B(LdaConstant), U8(123),
+ /* 1273 E> */ B(Star), R(0),
+ /* 1281 S> */ B(LdaConstant), U8(124),
+ /* 1283 E> */ B(Star), R(0),
+ /* 1291 S> */ B(LdaConstant), U8(125),
+ /* 1293 E> */ B(Star), R(0),
+ /* 1301 S> */ B(LdaConstant), U8(126),
+ /* 1303 E> */ B(Star), R(0),
+ /* 1311 S> */ B(LdaConstant), U8(127),
+ /* 1313 E> */ B(Star), R(0),
+ /* 1321 S> */ B(LdaConstant), U8(128),
+ /* 1323 E> */ B(Star), R(0),
+ /* 1331 S> */ B(LdaConstant), U8(129),
+ /* 1333 E> */ B(Star), R(0),
+ /* 1341 S> */ B(LdaConstant), U8(130),
+ /* 1343 E> */ B(Star), R(0),
+ /* 1351 S> */ B(LdaConstant), U8(131),
+ /* 1353 E> */ B(Star), R(0),
+ /* 1361 S> */ B(LdaConstant), U8(132),
+ /* 1363 E> */ B(Star), R(0),
+ /* 1371 S> */ B(LdaConstant), U8(133),
+ /* 1373 E> */ B(Star), R(0),
+ /* 1381 S> */ B(LdaConstant), U8(134),
+ /* 1383 E> */ B(Star), R(0),
+ /* 1391 S> */ B(LdaConstant), U8(135),
+ /* 1393 E> */ B(Star), R(0),
+ /* 1401 S> */ B(LdaConstant), U8(136),
+ /* 1403 E> */ B(Star), R(0),
+ /* 1411 S> */ B(LdaConstant), U8(137),
+ /* 1413 E> */ B(Star), R(0),
+ /* 1421 S> */ B(LdaConstant), U8(138),
+ /* 1423 E> */ B(Star), R(0),
+ /* 1431 S> */ B(LdaConstant), U8(139),
+ /* 1433 E> */ B(Star), R(0),
+ /* 1441 S> */ B(LdaConstant), U8(140),
+ /* 1443 E> */ B(Star), R(0),
+ /* 1451 S> */ B(LdaConstant), U8(141),
+ /* 1453 E> */ B(Star), R(0),
+ /* 1461 S> */ B(LdaConstant), U8(142),
+ /* 1463 E> */ B(Star), R(0),
+ /* 1471 S> */ B(LdaConstant), U8(143),
+ /* 1473 E> */ B(Star), R(0),
+ /* 1481 S> */ B(LdaConstant), U8(144),
+ /* 1483 E> */ B(Star), R(0),
+ /* 1491 S> */ B(LdaConstant), U8(145),
+ /* 1493 E> */ B(Star), R(0),
+ /* 1501 S> */ B(LdaConstant), U8(146),
+ /* 1503 E> */ B(Star), R(0),
+ /* 1511 S> */ B(LdaConstant), U8(147),
+ /* 1513 E> */ B(Star), R(0),
+ /* 1521 S> */ B(LdaConstant), U8(148),
+ /* 1523 E> */ B(Star), R(0),
+ /* 1531 S> */ B(LdaConstant), U8(149),
+ /* 1533 E> */ B(Star), R(0),
+ /* 1541 S> */ B(LdaConstant), U8(150),
+ /* 1543 E> */ B(Star), R(0),
+ /* 1551 S> */ B(LdaConstant), U8(151),
+ /* 1553 E> */ B(Star), R(0),
+ /* 1561 S> */ B(LdaConstant), U8(152),
+ /* 1563 E> */ B(Star), R(0),
+ /* 1571 S> */ B(LdaConstant), U8(153),
+ /* 1573 E> */ B(Star), R(0),
+ /* 1581 S> */ B(LdaConstant), U8(154),
+ /* 1583 E> */ B(Star), R(0),
+ /* 1591 S> */ B(LdaConstant), U8(155),
+ /* 1593 E> */ B(Star), R(0),
+ /* 1601 S> */ B(LdaConstant), U8(156),
+ /* 1603 E> */ B(Star), R(0),
+ /* 1611 S> */ B(LdaConstant), U8(157),
+ /* 1613 E> */ B(Star), R(0),
+ /* 1621 S> */ B(LdaConstant), U8(158),
+ /* 1623 E> */ B(Star), R(0),
+ /* 1631 S> */ B(LdaConstant), U8(159),
+ /* 1633 E> */ B(Star), R(0),
+ /* 1641 S> */ B(LdaConstant), U8(160),
+ /* 1643 E> */ B(Star), R(0),
+ /* 1651 S> */ B(LdaConstant), U8(161),
+ /* 1653 E> */ B(Star), R(0),
+ /* 1661 S> */ B(LdaConstant), U8(162),
+ /* 1663 E> */ B(Star), R(0),
+ /* 1671 S> */ B(LdaConstant), U8(163),
+ /* 1673 E> */ B(Star), R(0),
+ /* 1681 S> */ B(LdaConstant), U8(164),
+ /* 1683 E> */ B(Star), R(0),
+ /* 1691 S> */ B(LdaConstant), U8(165),
+ /* 1693 E> */ B(Star), R(0),
+ /* 1701 S> */ B(LdaConstant), U8(166),
+ /* 1703 E> */ B(Star), R(0),
+ /* 1711 S> */ B(LdaConstant), U8(167),
+ /* 1713 E> */ B(Star), R(0),
+ /* 1721 S> */ B(LdaConstant), U8(168),
+ /* 1723 E> */ B(Star), R(0),
+ /* 1731 S> */ B(LdaConstant), U8(169),
+ /* 1733 E> */ B(Star), R(0),
+ /* 1741 S> */ B(LdaConstant), U8(170),
+ /* 1743 E> */ B(Star), R(0),
+ /* 1751 S> */ B(LdaConstant), U8(171),
+ /* 1753 E> */ B(Star), R(0),
+ /* 1761 S> */ B(LdaConstant), U8(172),
+ /* 1763 E> */ B(Star), R(0),
+ /* 1771 S> */ B(LdaConstant), U8(173),
+ /* 1773 E> */ B(Star), R(0),
+ /* 1781 S> */ B(LdaConstant), U8(174),
+ /* 1783 E> */ B(Star), R(0),
+ /* 1791 S> */ B(LdaConstant), U8(175),
+ /* 1793 E> */ B(Star), R(0),
+ /* 1801 S> */ B(LdaConstant), U8(176),
+ /* 1803 E> */ B(Star), R(0),
+ /* 1811 S> */ B(LdaConstant), U8(177),
+ /* 1813 E> */ B(Star), R(0),
+ /* 1821 S> */ B(LdaConstant), U8(178),
+ /* 1823 E> */ B(Star), R(0),
+ /* 1831 S> */ B(LdaConstant), U8(179),
+ /* 1833 E> */ B(Star), R(0),
+ /* 1841 S> */ B(LdaConstant), U8(180),
+ /* 1843 E> */ B(Star), R(0),
+ /* 1851 S> */ B(LdaConstant), U8(181),
+ /* 1853 E> */ B(Star), R(0),
+ /* 1861 S> */ B(LdaConstant), U8(182),
+ /* 1863 E> */ B(Star), R(0),
+ /* 1871 S> */ B(LdaConstant), U8(183),
+ /* 1873 E> */ B(Star), R(0),
+ /* 1881 S> */ B(LdaConstant), U8(184),
+ /* 1883 E> */ B(Star), R(0),
+ /* 1891 S> */ B(LdaConstant), U8(185),
+ /* 1893 E> */ B(Star), R(0),
+ /* 1901 S> */ B(LdaConstant), U8(186),
+ /* 1903 E> */ B(Star), R(0),
+ /* 1911 S> */ B(LdaConstant), U8(187),
+ /* 1913 E> */ B(Star), R(0),
+ /* 1921 S> */ B(LdaConstant), U8(188),
+ /* 1923 E> */ B(Star), R(0),
+ /* 1931 S> */ B(LdaConstant), U8(189),
+ /* 1933 E> */ B(Star), R(0),
+ /* 1941 S> */ B(LdaConstant), U8(190),
+ /* 1943 E> */ B(Star), R(0),
+ /* 1951 S> */ B(LdaConstant), U8(191),
+ /* 1953 E> */ B(Star), R(0),
+ /* 1961 S> */ B(LdaConstant), U8(192),
+ /* 1963 E> */ B(Star), R(0),
+ /* 1971 S> */ B(LdaConstant), U8(193),
+ /* 1973 E> */ B(Star), R(0),
+ /* 1981 S> */ B(LdaConstant), U8(194),
+ /* 1983 E> */ B(Star), R(0),
+ /* 1991 S> */ B(LdaConstant), U8(195),
+ /* 1993 E> */ B(Star), R(0),
+ /* 2001 S> */ B(LdaConstant), U8(196),
+ /* 2003 E> */ B(Star), R(0),
+ /* 2011 S> */ B(LdaConstant), U8(197),
+ /* 2013 E> */ B(Star), R(0),
+ /* 2021 S> */ B(LdaConstant), U8(198),
+ /* 2023 E> */ B(Star), R(0),
+ /* 2031 S> */ B(LdaConstant), U8(199),
+ /* 2033 E> */ B(Star), R(0),
+ /* 2041 S> */ B(LdaConstant), U8(200),
+ /* 2043 E> */ B(Star), R(0),
+ /* 2051 S> */ B(LdaConstant), U8(201),
+ /* 2053 E> */ B(Star), R(0),
+ /* 2061 S> */ B(LdaConstant), U8(202),
+ /* 2063 E> */ B(Star), R(0),
+ /* 2071 S> */ B(LdaConstant), U8(203),
+ /* 2073 E> */ B(Star), R(0),
+ /* 2081 S> */ B(LdaConstant), U8(204),
+ /* 2083 E> */ B(Star), R(0),
+ /* 2091 S> */ B(LdaConstant), U8(205),
+ /* 2093 E> */ B(Star), R(0),
+ /* 2101 S> */ B(LdaConstant), U8(206),
+ /* 2103 E> */ B(Star), R(0),
+ /* 2111 S> */ B(LdaConstant), U8(207),
+ /* 2113 E> */ B(Star), R(0),
+ /* 2121 S> */ B(LdaConstant), U8(208),
+ /* 2123 E> */ B(Star), R(0),
+ /* 2131 S> */ B(LdaConstant), U8(209),
+ /* 2133 E> */ B(Star), R(0),
+ /* 2141 S> */ B(LdaConstant), U8(210),
+ /* 2143 E> */ B(Star), R(0),
+ /* 2151 S> */ B(LdaConstant), U8(211),
+ /* 2153 E> */ B(Star), R(0),
+ /* 2161 S> */ B(LdaConstant), U8(212),
+ /* 2163 E> */ B(Star), R(0),
+ /* 2171 S> */ B(LdaConstant), U8(213),
+ /* 2173 E> */ B(Star), R(0),
+ /* 2181 S> */ B(LdaConstant), U8(214),
+ /* 2183 E> */ B(Star), R(0),
+ /* 2191 S> */ B(LdaConstant), U8(215),
+ /* 2193 E> */ B(Star), R(0),
+ /* 2201 S> */ B(LdaConstant), U8(216),
+ /* 2203 E> */ B(Star), R(0),
+ /* 2211 S> */ B(LdaConstant), U8(217),
+ /* 2213 E> */ B(Star), R(0),
+ /* 2221 S> */ B(LdaConstant), U8(218),
+ /* 2223 E> */ B(Star), R(0),
+ /* 2231 S> */ B(LdaConstant), U8(219),
+ /* 2233 E> */ B(Star), R(0),
+ /* 2241 S> */ B(LdaConstant), U8(220),
+ /* 2243 E> */ B(Star), R(0),
+ /* 2251 S> */ B(LdaConstant), U8(221),
+ /* 2253 E> */ B(Star), R(0),
+ /* 2261 S> */ B(LdaConstant), U8(222),
+ /* 2263 E> */ B(Star), R(0),
+ /* 2271 S> */ B(LdaConstant), U8(223),
+ /* 2273 E> */ B(Star), R(0),
+ /* 2281 S> */ B(LdaConstant), U8(224),
+ /* 2283 E> */ B(Star), R(0),
+ /* 2291 S> */ B(LdaConstant), U8(225),
+ /* 2293 E> */ B(Star), R(0),
+ /* 2301 S> */ B(LdaConstant), U8(226),
+ /* 2303 E> */ B(Star), R(0),
+ /* 2311 S> */ B(LdaConstant), U8(227),
+ /* 2313 E> */ B(Star), R(0),
+ /* 2321 S> */ B(LdaConstant), U8(228),
+ /* 2323 E> */ B(Star), R(0),
+ /* 2331 S> */ B(LdaConstant), U8(229),
+ /* 2333 E> */ B(Star), R(0),
+ /* 2341 S> */ B(LdaConstant), U8(230),
+ /* 2343 E> */ B(Star), R(0),
+ /* 2351 S> */ B(LdaConstant), U8(231),
+ /* 2353 E> */ B(Star), R(0),
+ /* 2361 S> */ B(LdaConstant), U8(232),
+ /* 2363 E> */ B(Star), R(0),
+ /* 2371 S> */ B(LdaConstant), U8(233),
+ /* 2373 E> */ B(Star), R(0),
+ /* 2381 S> */ B(LdaConstant), U8(234),
+ /* 2383 E> */ B(Star), R(0),
+ /* 2391 S> */ B(LdaConstant), U8(235),
+ /* 2393 E> */ B(Star), R(0),
+ /* 2401 S> */ B(LdaConstant), U8(236),
+ /* 2403 E> */ B(Star), R(0),
+ /* 2411 S> */ B(LdaConstant), U8(237),
+ /* 2413 E> */ B(Star), R(0),
+ /* 2421 S> */ B(LdaConstant), U8(238),
+ /* 2423 E> */ B(Star), R(0),
+ /* 2431 S> */ B(LdaConstant), U8(239),
+ /* 2433 E> */ B(Star), R(0),
+ /* 2441 S> */ B(LdaConstant), U8(240),
+ /* 2443 E> */ B(Star), R(0),
+ /* 2451 S> */ B(LdaConstant), U8(241),
+ /* 2453 E> */ B(Star), R(0),
+ /* 2461 S> */ B(LdaConstant), U8(242),
+ /* 2463 E> */ B(Star), R(0),
+ /* 2471 S> */ B(LdaConstant), U8(243),
+ /* 2473 E> */ B(Star), R(0),
+ /* 2481 S> */ B(LdaConstant), U8(244),
+ /* 2483 E> */ B(Star), R(0),
+ /* 2491 S> */ B(LdaConstant), U8(245),
+ /* 2493 E> */ B(Star), R(0),
+ /* 2501 S> */ B(LdaConstant), U8(246),
+ /* 2503 E> */ B(Star), R(0),
+ /* 2511 S> */ B(LdaConstant), U8(247),
+ /* 2513 E> */ B(Star), R(0),
+ /* 2521 S> */ B(LdaConstant), U8(248),
+ /* 2523 E> */ B(Star), R(0),
+ /* 2531 S> */ B(LdaConstant), U8(249),
+ /* 2533 E> */ B(Star), R(0),
+ /* 2541 S> */ B(LdaConstant), U8(250),
+ /* 2543 E> */ B(Star), R(0),
+ /* 2551 S> */ B(LdaConstant), U8(251),
+ /* 2553 E> */ B(Star), R(0),
+ /* 2561 S> */ B(LdaConstant), U8(252),
+ /* 2563 E> */ B(Star), R(0),
+ /* 2571 S> */ B(LdaConstant), U8(253),
+ /* 2573 E> */ B(Star), R(0),
+ /* 2581 S> */ B(LdaConstant), U8(254),
+ /* 2583 E> */ B(Star), R(0),
+ /* 2591 S> */ B(LdaConstant), U8(255),
+ /* 2593 E> */ B(Star), R(0),
+ /* 2601 S> */ B(Wide), B(CreateArrayLiteral), U16(256), U16(0), U8(3),
+ /* 2619 S> */ B(Return),
]
constant pool: [
InstanceType::HEAP_NUMBER_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/AssignmentsInBinaryExpression.golden b/test/cctest/interpreter/bytecode_expectations/AssignmentsInBinaryExpression.golden
index f569bab..c80469b 100644
--- a/test/cctest/interpreter/bytecode_expectations/AssignmentsInBinaryExpression.golden
+++ b/test/cctest/interpreter/bytecode_expectations/AssignmentsInBinaryExpression.golden
@@ -16,20 +16,20 @@
parameter count: 1
bytecode array length: 25
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(0),
- B(LdaSmi), U8(3),
- B(Star), R(1),
- B(LdaSmi), U8(4),
- B(Star), R(0),
- B(LdaSmi), U8(5),
- B(Star), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 49 S> */ B(LdaSmi), U8(1),
+ /* 49 E> */ B(Star), R(1),
+ /* 52 S> */ B(LdaSmi), U8(2),
+ /* 62 E> */ B(Star), R(0),
+ B(LdaSmi), U8(3),
+ /* 69 E> */ B(Star), R(1),
+ B(LdaSmi), U8(4),
+ /* 76 E> */ B(Star), R(0),
+ B(LdaSmi), U8(5),
+ /* 83 E> */ B(Star), R(1),
+ /* 89 S> */ B(Return),
]
constant pool: [
]
@@ -46,13 +46,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(55),
- B(Star), R(0),
- B(LdaSmi), U8(100),
- B(Star), R(0),
- B(Star), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(55),
+ /* 42 E> */ B(Star), R(0),
+ /* 57 S> */ B(LdaSmi), U8(100),
+ /* 57 E> */ B(Star), R(0),
+ /* 57 E> */ B(Star), R(1),
+ /* 75 S> */ B(Return),
]
constant pool: [
]
@@ -69,19 +69,19 @@
parameter count: 1
bytecode array length: 24
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(55),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(100),
- B(Star), R(0),
- B(Add), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(101),
- B(Star), R(0),
- B(Add), R(2),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(55),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(Star), R(1),
+ B(LdaSmi), U8(100),
+ /* 57 E> */ B(Star), R(0),
+ B(Add), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(101),
+ /* 69 E> */ B(Star), R(0),
+ B(Add), R(2),
+ /* 48 E> */ B(Star), R(0),
+ /* 87 S> */ B(Return),
]
constant pool: [
]
@@ -99,24 +99,24 @@
parameter count: 1
bytecode array length: 32
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(55),
- B(Star), R(0),
- B(LdaSmi), U8(56),
- B(Star), R(0),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Sub), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(57),
- B(Star), R(0),
- B(Add), R(2),
- B(Star), R(0),
- B(ToNumber),
- B(Star), R(1),
- B(Inc),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(55),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(LdaSmi), U8(56),
+ /* 53 E> */ B(Star), R(0),
+ B(Star), R(1),
+ /* 61 E> */ B(Ldar), R(0),
+ B(Sub), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(57),
+ /* 68 E> */ B(Star), R(0),
+ B(Add), R(2),
+ /* 48 E> */ B(Star), R(0),
+ /* 75 S> */ B(ToNumber),
+ B(Star), R(1),
+ B(Inc),
+ /* 76 E> */ B(Star), R(0),
+ /* 90 S> */ B(Return),
]
constant pool: [
]
@@ -133,23 +133,23 @@
parameter count: 1
bytecode array length: 32
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(55),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Add), R(2),
- B(Star), R(3),
- B(LdaSmi), U8(2),
- B(Star), R(0),
- B(Add), R(3),
- B(Star), R(2),
- B(LdaSmi), U8(3),
- B(Star), R(0),
- B(Add), R(2),
- B(Star), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(55),
+ /* 42 E> */ B(Star), R(0),
+ /* 76 S> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 61 E> */ B(Star), R(0),
+ B(Add), R(2),
+ B(Star), R(3),
+ B(LdaSmi), U8(2),
+ /* 71 E> */ B(Star), R(0),
+ B(Add), R(3),
+ B(Star), R(2),
+ B(LdaSmi), U8(3),
+ /* 81 E> */ B(Star), R(0),
+ B(Add), R(2),
+ /* 76 E> */ B(Star), R(1),
+ /* 97 S> */ B(Return),
]
constant pool: [
]
@@ -166,23 +166,23 @@
parameter count: 1
bytecode array length: 32
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(55),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Add), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(2),
- B(Star), R(0),
- B(Add), R(2),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Star), R(0),
- B(Add), R(1),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(55),
+ /* 42 E> */ B(Star), R(0),
+ /* 76 S> */ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 61 E> */ B(Star), R(0),
+ B(Add), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(2),
+ /* 71 E> */ B(Star), R(0),
+ B(Add), R(2),
+ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ /* 81 E> */ B(Star), R(0),
+ B(Add), R(1),
+ /* 76 E> */ B(Star), R(0),
+ /* 97 S> */ B(Return),
]
constant pool: [
]
@@ -198,42 +198,42 @@
parameter count: 1
bytecode array length: 70
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(LdaSmi), U8(20),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Add), R(2),
- B(Star), R(3),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Add), R(2),
- B(Star), R(4),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(Mul), R(4),
- B(Add), R(3),
- B(Star), R(2),
- B(LdaSmi), U8(3),
- B(Star), R(1),
- B(Add), R(2),
- B(Star), R(3),
- B(LdaSmi), U8(4),
- B(Star), R(0),
- B(Add), R(3),
- B(Star), R(2),
- B(LdaSmi), U8(5),
- B(Star), R(1),
- B(Add), R(2),
- B(Star), R(3),
- B(Ldar), R(1),
- B(Add), R(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(Star), R(0),
+ /* 50 S> */ B(LdaSmi), U8(20),
+ /* 50 E> */ B(Star), R(1),
+ /* 54 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 68 E> */ B(Star), R(0),
+ B(Add), R(2),
+ B(Star), R(3),
+ /* 76 E> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Add), R(2),
+ B(Star), R(4),
+ B(LdaSmi), U8(2),
+ /* 88 E> */ B(Star), R(1),
+ B(Mul), R(4),
+ B(Add), R(3),
+ B(Star), R(2),
+ B(LdaSmi), U8(3),
+ /* 98 E> */ B(Star), R(1),
+ B(Add), R(2),
+ B(Star), R(3),
+ B(LdaSmi), U8(4),
+ /* 108 E> */ B(Star), R(0),
+ B(Add), R(3),
+ B(Star), R(2),
+ B(LdaSmi), U8(5),
+ /* 118 E> */ B(Star), R(1),
+ B(Add), R(2),
+ B(Star), R(3),
+ /* 125 E> */ B(Ldar), R(1),
+ B(Add), R(3),
+ /* 128 S> */ B(Return),
]
constant pool: [
]
@@ -247,30 +247,29 @@
"
frame size: 4
parameter count: 1
-bytecode array length: 38
+bytecode array length: 37
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(17),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Add), R(1),
- B(Star), R(2),
- B(Ldar), R(0),
- B(ToNumber),
- B(Star), R(1),
- B(Inc),
- B(Star), R(0),
- B(Ldar), R(1),
- B(Add), R(2),
- B(Star), R(3),
- B(Ldar), R(0),
- B(ToNumber),
- B(Inc),
- B(Star), R(0),
- B(Add), R(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(17),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(LdaSmi), U8(1),
+ B(Star), R(1),
+ /* 57 E> */ B(Ldar), R(0),
+ B(Add), R(1),
+ B(Star), R(2),
+ B(Ldar), R(0),
+ B(ToNumber),
+ B(Star), R(1),
+ B(Inc),
+ /* 63 E> */ B(Star), R(0),
+ B(Ldar), R(1),
+ B(Add), R(2),
+ B(Star), R(3),
+ B(Ldar), R(0),
+ B(Inc),
+ /* 72 E> */ B(Star), R(0),
+ B(Add), R(3),
+ /* 76 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/BasicBlockToBoolean.golden b/test/cctest/interpreter/bytecode_expectations/BasicBlockToBoolean.golden
index ee98e5a..6aa50ef 100644
--- a/test/cctest/interpreter/bytecode_expectations/BasicBlockToBoolean.golden
+++ b/test/cctest/interpreter/bytecode_expectations/BasicBlockToBoolean.golden
@@ -15,19 +15,19 @@
parameter count: 1
bytecode array length: 21
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(JumpIfToBooleanTrue), U8(9),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaZero),
- B(TestLessThan), R(1),
- B(JumpIfToBooleanFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanTrue), U8(9),
+ /* 54 E> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaZero),
+ /* 56 E> */ B(TestLessThan), R(1),
+ B(JumpIfToBooleanFalse), U8(5),
+ /* 63 S> */ B(LdaSmi), U8(1),
+ /* 75 S> */ B(Return),
+ B(LdaUndefined),
+ /* 75 S> */ B(Return),
]
constant pool: [
]
@@ -42,19 +42,19 @@
parameter count: 1
bytecode array length: 21
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(JumpIfToBooleanFalse), U8(9),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaZero),
- B(TestLessThan), R(1),
- B(JumpIfToBooleanFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanFalse), U8(9),
+ /* 54 E> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaZero),
+ /* 56 E> */ B(TestLessThan), R(1),
+ B(JumpIfToBooleanFalse), U8(5),
+ /* 63 S> */ B(LdaSmi), U8(1),
+ /* 75 S> */ B(Return),
+ B(LdaUndefined),
+ /* 75 S> */ B(Return),
]
constant pool: [
]
@@ -69,21 +69,21 @@
parameter count: 1
bytecode array length: 26
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(JumpIfToBooleanTrue), U8(9),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaZero),
- B(TestLessThan), R(1),
- B(JumpIfToBooleanFalse), U8(6),
- B(LdaSmi), U8(2),
- B(Jump), U8(4),
- B(LdaSmi), U8(3),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanTrue), U8(9),
+ /* 55 E> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaZero),
+ /* 57 E> */ B(TestLessThan), R(1),
+ B(JumpIfToBooleanFalse), U8(6),
+ B(LdaSmi), U8(2),
+ B(Jump), U8(4),
+ B(LdaSmi), U8(3),
+ /* 47 E> */ B(Star), R(0),
+ B(LdaUndefined),
+ /* 71 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/BasicLoops.golden b/test/cctest/interpreter/bytecode_expectations/BasicLoops.golden
index 05ee657..7936736 100644
--- a/test/cctest/interpreter/bytecode_expectations/BasicLoops.golden
+++ b/test/cctest/interpreter/bytecode_expectations/BasicLoops.golden
@@ -17,10 +17,10 @@
parameter count: 1
bytecode array length: 5
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 98 S> */ B(Return),
]
constant pool: [
]
@@ -39,10 +39,10 @@
parameter count: 1
bytecode array length: 5
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 87 S> */ B(Return),
]
constant pool: [
]
@@ -65,41 +65,41 @@
parameter count: 1
bytecode array length: 66
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(10),
- B(TestLessThan), R(2),
- B(JumpIfFalse), U8(47),
- B(StackCheck),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(12),
- B(Mul), R(2),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Add), R(2),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(3),
- B(TestEqual), R(2),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(-39),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(4),
- B(TestEqual), R(2),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(4),
- B(Jump), U8(-53),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 53 S> */ B(LdaSmi), U8(1),
+ /* 53 E> */ B(Star), R(1),
+ /* 65 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(10),
+ /* 65 E> */ B(TestLessThan), R(2),
+ B(JumpIfFalse), U8(47),
+ /* 56 E> */ B(StackCheck),
+ /* 75 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(12),
+ B(Mul), R(2),
+ /* 77 E> */ B(Star), R(1),
+ /* 89 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Add), R(2),
+ /* 91 E> */ B(Star), R(0),
+ /* 102 S> */ B(Star), R(2),
+ B(LdaSmi), U8(3),
+ /* 108 E> */ B(TestEqual), R(2),
+ B(JumpIfFalse), U8(4),
+ /* 114 S> */ B(Jump), U8(14),
+ /* 126 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(4),
+ /* 132 E> */ B(TestEqual), R(2),
+ B(JumpIfFalse), U8(4),
+ /* 138 S> */ B(Jump), U8(4),
+ B(Jump), U8(-53),
+ /* 147 S> */ B(Ldar), R(1),
+ /* 157 S> */ B(Return),
]
constant pool: [
]
@@ -123,48 +123,48 @@
parameter count: 1
bytecode array length: 79
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaZero),
- B(TestLessThan), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(-10),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(50),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(4),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(38),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(10),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(-46),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(5),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(14),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Add), R(1),
- B(Star), R(0),
- B(Jump), U8(-70),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 E> */ B(StackCheck),
+ /* 62 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaZero),
+ /* 68 E> */ B(TestLessThan), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 73 S> */ B(Jump), U8(60),
+ /* 85 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ /* 91 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 97 S> */ B(Jump), U8(50),
+ /* 106 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(4),
+ /* 112 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 118 S> */ B(Jump), U8(38),
+ /* 127 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(10),
+ /* 133 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 140 S> */ B(Jump), U8(24),
+ /* 152 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(5),
+ /* 158 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 164 S> */ B(Jump), U8(14),
+ /* 173 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Add), R(1),
+ /* 175 E> */ B(Star), R(0),
+ B(Jump), U8(-70),
+ /* 186 S> */ B(Ldar), R(0),
+ /* 196 S> */ B(Return),
]
constant pool: [
]
@@ -188,37 +188,37 @@
parameter count: 1
bytecode array length: 57
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(TestLessThan), R(1),
- B(JumpIfFalse), U8(27),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(14),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Add), R(1),
- B(Star), R(0),
- B(Jump), U8(-33),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Add), R(1),
- B(Star), R(0),
- B(Jump), U8(4),
- B(Jump), U8(-48),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 E> */ B(StackCheck),
+ /* 71 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ /* 71 E> */ B(TestLessThan), R(1),
+ B(JumpIfFalse), U8(27),
+ /* 62 E> */ B(StackCheck),
+ /* 82 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 88 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 94 S> */ B(Jump), U8(14),
+ /* 105 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Add), R(1),
+ /* 107 E> */ B(Star), R(0),
+ B(Jump), U8(-33),
+ /* 122 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Add), R(1),
+ /* 124 E> */ B(Star), R(0),
+ /* 135 S> */ B(Jump), U8(4),
+ B(Jump), U8(-48),
+ /* 144 S> */ B(Ldar), R(0),
+ /* 154 S> */ B(Return),
]
constant pool: [
]
@@ -239,27 +239,27 @@
parameter count: 1
bytecode array length: 39
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfToBooleanFalse), U8(25),
- B(StackCheck),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(12),
- B(Mul), R(2),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Sub), R(2),
- B(Star), R(0),
- B(Jump), U8(-25),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(Star), R(0),
+ /* 54 S> */ B(LdaSmi), U8(1),
+ /* 54 E> */ B(Star), R(1),
+ /* 64 S> */ B(Ldar), R(0),
+ B(JumpIfToBooleanFalse), U8(25),
+ /* 57 E> */ B(StackCheck),
+ /* 71 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(12),
+ B(Mul), R(2),
+ /* 73 E> */ B(Star), R(1),
+ /* 85 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Sub), R(2),
+ /* 87 E> */ B(Star), R(0),
+ B(Jump), U8(-25),
+ /* 98 S> */ B(Ldar), R(1),
+ /* 108 S> */ B(Return),
]
constant pool: [
]
@@ -281,41 +281,41 @@
parameter count: 1
bytecode array length: 66
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(StackCheck),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(10),
- B(Mul), R(2),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(5),
- B(TestEqual), R(2),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(34),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(6),
- B(TestEqual), R(2),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(12),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Add), R(2),
- B(Star), R(0),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(10),
- B(TestLessThan), R(2),
- B(JumpIfTrue), U8(-53),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 53 S> */ B(LdaSmi), U8(1),
+ /* 53 E> */ B(Star), R(1),
+ /* 56 E> */ B(StackCheck),
+ /* 63 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(10),
+ B(Mul), R(2),
+ /* 65 E> */ B(Star), R(1),
+ /* 77 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(5),
+ /* 83 E> */ B(TestEqual), R(2),
+ B(JumpIfFalse), U8(4),
+ /* 89 S> */ B(Jump), U8(34),
+ /* 98 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(6),
+ /* 104 E> */ B(TestEqual), R(2),
+ B(JumpIfFalse), U8(4),
+ /* 110 S> */ B(Jump), U8(12),
+ /* 122 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Add), R(2),
+ /* 124 E> */ B(Star), R(0),
+ /* 144 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(10),
+ /* 144 E> */ B(TestLessThan), R(2),
+ B(JumpIfTrue), U8(-53),
+ /* 151 S> */ B(Ldar), R(1),
+ /* 161 S> */ B(Return),
]
constant pool: [
]
@@ -336,26 +336,26 @@
parameter count: 1
bytecode array length: 37
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(StackCheck),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(12),
- B(Mul), R(2),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Sub), R(2),
- B(Star), R(0),
- B(Ldar), R(0),
- B(JumpIfToBooleanTrue), U8(-23),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(Star), R(0),
+ /* 54 S> */ B(LdaSmi), U8(1),
+ /* 54 E> */ B(Star), R(1),
+ /* 57 E> */ B(StackCheck),
+ /* 64 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(12),
+ B(Mul), R(2),
+ /* 66 E> */ B(Star), R(1),
+ /* 78 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Sub), R(2),
+ /* 80 E> */ B(Star), R(0),
+ /* 98 S> */ B(Ldar), R(0),
+ B(JumpIfToBooleanTrue), U8(-23),
+ /* 102 S> */ B(Ldar), R(1),
+ /* 112 S> */ B(Return),
]
constant pool: [
]
@@ -377,35 +377,35 @@
parameter count: 1
bytecode array length: 54
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(StackCheck),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(10),
- B(Mul), R(2),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(5),
- B(TestEqual), R(2),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(22),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Add), R(2),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(6),
- B(TestEqual), R(2),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(2),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 53 S> */ B(LdaSmi), U8(1),
+ /* 53 E> */ B(Star), R(1),
+ /* 56 E> */ B(StackCheck),
+ /* 63 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(10),
+ B(Mul), R(2),
+ /* 65 E> */ B(Star), R(1),
+ /* 77 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(5),
+ /* 83 E> */ B(TestEqual), R(2),
+ B(JumpIfFalse), U8(4),
+ /* 89 S> */ B(Jump), U8(22),
+ /* 98 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Add), R(2),
+ /* 100 E> */ B(Star), R(0),
+ /* 111 S> */ B(Star), R(2),
+ B(LdaSmi), U8(6),
+ /* 117 E> */ B(TestEqual), R(2),
+ B(JumpIfFalse), U8(4),
+ /* 123 S> */ B(Jump), U8(2),
+ /* 150 S> */ B(Ldar), R(1),
+ /* 160 S> */ B(Return),
]
constant pool: [
]
@@ -427,36 +427,36 @@
parameter count: 1
bytecode array length: 56
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(StackCheck),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(10),
- B(Mul), R(2),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(5),
- B(TestEqual), R(2),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(24),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Add), R(2),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(6),
- B(TestEqual), R(2),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(-41),
- B(Jump), U8(-43),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 53 S> */ B(LdaSmi), U8(1),
+ /* 53 E> */ B(Star), R(1),
+ /* 56 E> */ B(StackCheck),
+ /* 63 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(10),
+ B(Mul), R(2),
+ /* 65 E> */ B(Star), R(1),
+ /* 77 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(5),
+ /* 83 E> */ B(TestEqual), R(2),
+ B(JumpIfFalse), U8(4),
+ /* 89 S> */ B(Jump), U8(24),
+ /* 98 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Add), R(2),
+ /* 100 E> */ B(Star), R(0),
+ /* 111 S> */ B(Star), R(2),
+ B(LdaSmi), U8(6),
+ /* 117 E> */ B(TestEqual), R(2),
+ B(JumpIfFalse), U8(4),
+ /* 123 S> */ B(Jump), U8(2),
+ B(Jump), U8(-43),
+ /* 149 S> */ B(Ldar), R(1),
+ /* 159 S> */ B(Return),
]
constant pool: [
]
@@ -476,30 +476,30 @@
parameter count: 1
bytecode array length: 43
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(26),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(-23),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Add), R(1),
- B(Star), R(0),
- B(Jump), U8(-35),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 E> */ B(StackCheck),
+ /* 58 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 64 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 70 S> */ B(Jump), U8(26),
+ /* 79 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 85 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 91 S> */ B(Jump), U8(12),
+ /* 103 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Add), R(1),
+ /* 105 E> */ B(Star), R(0),
+ B(Jump), U8(-35),
+ B(LdaUndefined),
+ /* 116 S> */ B(Return),
]
constant pool: [
]
@@ -518,30 +518,30 @@
parameter count: 1
bytecode array length: 43
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(26),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(-23),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Add), R(1),
- B(Star), R(0),
- B(Jump), U8(-35),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 47 S> */ B(LdaZero),
+ /* 47 E> */ B(Star), R(0),
+ /* 34 E> */ B(StackCheck),
+ /* 56 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 62 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 68 S> */ B(Jump), U8(26),
+ /* 77 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 83 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 89 S> */ B(Jump), U8(12),
+ /* 101 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Add), R(1),
+ /* 103 E> */ B(Star), R(0),
+ B(Jump), U8(-35),
+ B(LdaUndefined),
+ /* 114 S> */ B(Return),
]
constant pool: [
]
@@ -560,30 +560,30 @@
parameter count: 1
bytecode array length: 43
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(26),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(2),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Add), R(1),
- B(Star), R(0),
- B(Jump), U8(-35),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 E> */ B(StackCheck),
+ /* 68 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 74 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 80 S> */ B(Jump), U8(26),
+ /* 89 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 95 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 101 S> */ B(Jump), U8(2),
+ /* 55 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Add), R(1),
+ /* 55 E> */ B(Star), R(0),
+ B(Jump), U8(-35),
+ B(LdaUndefined),
+ /* 113 S> */ B(Return),
]
constant pool: [
]
@@ -601,30 +601,30 @@
parameter count: 1
bytecode array length: 43
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(26),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(2),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Add), R(1),
- B(Star), R(0),
- B(Jump), U8(-35),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 47 S> */ B(LdaZero),
+ /* 47 E> */ B(Star), R(0),
+ /* 34 E> */ B(StackCheck),
+ /* 66 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 72 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 78 S> */ B(Jump), U8(26),
+ /* 87 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 93 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 99 S> */ B(Jump), U8(2),
+ /* 53 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Add), R(1),
+ /* 53 E> */ B(Star), R(0),
+ B(Jump), U8(-35),
+ B(LdaUndefined),
+ /* 111 S> */ B(Return),
]
constant pool: [
]
@@ -643,31 +643,31 @@
parameter count: 1
bytecode array length: 44
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaZero),
- B(Star), R(1),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(100),
- B(TestLessThan), R(2),
- B(JumpIfFalse), U8(27),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Add), R(2),
- B(Star), R(0),
- B(Jump), U8(2),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Add), R(2),
- B(Star), R(1),
- B(Jump), U8(-33),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 58 S> */ B(LdaZero),
+ /* 58 E> */ B(Star), R(1),
+ /* 63 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(100),
+ /* 63 E> */ B(TestLessThan), R(2),
+ B(JumpIfFalse), U8(27),
+ /* 45 E> */ B(StackCheck),
+ /* 85 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Add), R(2),
+ /* 87 E> */ B(Star), R(0),
+ /* 98 S> */ B(Jump), U8(2),
+ /* 72 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Add), R(2),
+ /* 72 E> */ B(Star), R(1),
+ B(Jump), U8(-33),
+ B(LdaUndefined),
+ /* 110 S> */ B(Return),
]
constant pool: [
]
@@ -684,28 +684,27 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 35
+bytecode array length: 34
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(LdaSmi), U8(10),
- B(Star), R(1),
- B(Ldar), R(1),
- B(JumpIfToBooleanFalse), U8(21),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(12),
- B(Mul), R(2),
- B(Star), R(0),
- B(Ldar), R(1),
- B(ToNumber),
- B(Dec),
- B(Star), R(1),
- B(Jump), U8(-21),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 58 S> */ B(LdaSmi), U8(10),
+ /* 58 E> */ B(Star), R(1),
+ /* 62 S> */ B(Ldar), R(1),
+ B(JumpIfToBooleanFalse), U8(20),
+ /* 45 E> */ B(StackCheck),
+ /* 74 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(12),
+ B(Mul), R(2),
+ /* 76 E> */ B(Star), R(0),
+ /* 67 S> */ B(Ldar), R(1),
+ B(Dec),
+ /* 67 E> */ B(Star), R(1),
+ B(Jump), U8(-20),
+ /* 88 S> */ B(Ldar), R(0),
+ /* 98 S> */ B(Return),
]
constant pool: [
]
@@ -724,13 +723,13 @@
parameter count: 1
bytecode array length: 10
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaZero),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 58 S> */ B(LdaZero),
+ /* 58 E> */ B(Star), R(1),
+ /* 91 S> */ B(Ldar), R(0),
+ /* 101 S> */ B(Return),
]
constant pool: [
]
@@ -748,31 +747,30 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 39
+bytecode array length: 38
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaZero),
- B(Star), R(1),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Add), R(2),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(20),
- B(TestEqual), R(2),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(10),
- B(Ldar), R(1),
- B(ToNumber),
- B(Inc),
- B(Star), R(1),
- B(Jump), U8(-27),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 58 S> */ B(LdaZero),
+ /* 58 E> */ B(Star), R(1),
+ /* 45 E> */ B(StackCheck),
+ /* 76 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Add), R(2),
+ /* 78 E> */ B(Star), R(0),
+ /* 89 S> */ B(Star), R(2),
+ B(LdaSmi), U8(20),
+ /* 95 E> */ B(TestEqual), R(2),
+ B(JumpIfFalse), U8(4),
+ /* 102 S> */ B(Jump), U8(9),
+ /* 69 S> */ B(Ldar), R(1),
+ B(Inc),
+ /* 69 E> */ B(Star), R(1),
+ B(Jump), U8(-26),
+ /* 112 S> */ B(Ldar), R(0),
+ /* 122 S> */ B(Return),
]
constant pool: [
]
@@ -795,59 +793,59 @@
parameter count: 1
bytecode array length: 120
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(1),
- B(Ldar), R(1),
- B(JumpIfToBooleanFalse), U8(112),
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(4),
- B(Ldar), R(closure),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kPushBlockContext), R(4), U8(2),
- B(PushContext), R(3),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(1), U8(0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StaContextSlot), R(context), U8(4),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(2),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
- B(Star), R(2),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(3),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
- B(JumpIfToBooleanFalse), U8(8),
- B(PopContext), R(3),
- B(PopContext), R(3),
- B(Jump), U8(-69),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(3),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
- B(ToNumber),
- B(Star), R(4),
- B(Inc),
- B(Star), R(5),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(3),
- B(Star), R(6),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(6), U8(1),
- B(Ldar), R(5),
- B(StaContextSlot), R(context), U8(4),
- B(PopContext), R(3),
- B(Jump), U8(-112),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(1),
+ /* 52 S> */ B(Ldar), R(1),
+ B(JumpIfToBooleanFalse), U8(112),
+ /* 45 E> */ B(StackCheck),
+ B(LdaConstant), U8(0),
+ B(Star), R(4),
+ B(Ldar), R(closure),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kPushBlockContext), R(4), U8(2),
+ B(PushContext), R(3),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(1), U8(0),
+ B(Star), R(0),
+ /* 73 S> */ B(LdaSmi), U8(1),
+ /* 73 E> */ B(StaContextSlot), R(context), U8(4),
+ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(2),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
+ B(Star), R(2),
+ /* 106 S> */ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(3),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
+ B(JumpIfToBooleanFalse), U8(8),
+ /* 113 S> */ B(PopContext), R(3),
+ B(PopContext), R(3),
+ B(Jump), U8(43),
+ /* 126 S> */ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(3),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
+ B(ToNumber),
+ B(Star), R(4),
+ B(Inc),
+ /* 127 E> */ B(Star), R(5),
+ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(3),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(6), U8(1),
+ B(Ldar), R(5),
+ B(StaContextSlot), R(context), U8(4),
+ B(PopContext), R(3),
+ B(Jump), U8(-112),
+ B(LdaUndefined),
+ /* 137 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/BreakableBlocks.golden b/test/cctest/interpreter/bytecode_expectations/BreakableBlocks.golden
index 162297d..8573a1a 100644
--- a/test/cctest/interpreter/bytecode_expectations/BreakableBlocks.golden
+++ b/test/cctest/interpreter/bytecode_expectations/BreakableBlocks.golden
@@ -21,16 +21,16 @@
parameter count: 1
bytecode array length: 17
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Add), R(1),
- B(Star), R(0),
- B(Jump), U8(2),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 56 S> */ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Add), R(1),
+ /* 58 E> */ B(Star), R(0),
+ /* 69 S> */ B(Jump), U8(2),
+ /* 97 S> */ B(Ldar), R(0),
+ /* 107 S> */ B(Return),
]
constant pool: [
]
@@ -52,52 +52,49 @@
"
frame size: 5
parameter count: 1
-bytecode array length: 75
+bytecode array length: 72
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaZero),
- B(Star), R(1),
- B(Ldar), R(1),
- B(Star), R(3),
- B(LdaSmi), U8(10),
- B(TestLessThan), R(3),
- B(JumpIfFalse), U8(57),
- B(StackCheck),
- B(LdaZero),
- B(Star), R(2),
- B(Ldar), R(2),
- B(Star), R(3),
- B(LdaSmi), U8(3),
- B(TestLessThan), R(3),
- B(JumpIfFalse), U8(35),
- B(StackCheck),
- B(Ldar), R(0),
- B(ToNumber),
- B(Inc),
- B(Star), R(0),
- B(Ldar), R(1),
- B(Star), R(3),
- B(Ldar), R(2),
- B(Add), R(3),
- B(Star), R(4),
- B(LdaSmi), U8(12),
- B(TestEqual), R(4),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(18),
- B(Ldar), R(2),
- B(ToNumber),
- B(Inc),
- B(Star), R(2),
- B(Jump), U8(-41),
- B(Ldar), R(1),
- B(ToNumber),
- B(Inc),
- B(Star), R(1),
- B(Jump), U8(-63),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 44 S> */ B(LdaZero),
+ /* 44 E> */ B(Star), R(0),
+ /* 71 S> */ B(LdaZero),
+ /* 71 E> */ B(Star), R(1),
+ /* 76 S> */ B(Ldar), R(1),
+ B(Star), R(3),
+ B(LdaSmi), U8(10),
+ /* 76 E> */ B(TestLessThan), R(3),
+ B(JumpIfFalse), U8(54),
+ /* 58 E> */ B(StackCheck),
+ /* 106 S> */ B(LdaZero),
+ /* 106 E> */ B(Star), R(2),
+ /* 111 S> */ B(Ldar), R(2),
+ B(Star), R(3),
+ B(LdaSmi), U8(3),
+ /* 111 E> */ B(TestLessThan), R(3),
+ B(JumpIfFalse), U8(33),
+ /* 93 E> */ B(StackCheck),
+ /* 129 S> */ B(Ldar), R(0),
+ B(Inc),
+ /* 131 E> */ B(Star), R(0),
+ /* 142 S> */ B(Ldar), R(1),
+ B(Star), R(3),
+ /* 150 E> */ B(Ldar), R(2),
+ B(Add), R(3),
+ B(Star), R(4),
+ B(LdaSmi), U8(12),
+ /* 152 E> */ B(TestEqual), R(4),
+ B(JumpIfFalse), U8(4),
+ /* 161 S> */ B(Jump), U8(16),
+ /* 118 S> */ B(Ldar), R(2),
+ B(Inc),
+ /* 118 E> */ B(Star), R(2),
+ B(Jump), U8(-39),
+ /* 84 S> */ B(Ldar), R(1),
+ B(Inc),
+ /* 84 E> */ B(Star), R(1),
+ B(Jump), U8(-60),
+ /* 188 S> */ B(Ldar), R(0),
+ /* 200 S> */ B(Return),
]
constant pool: [
]
@@ -116,29 +113,29 @@
parameter count: 1
bytecode array length: 51
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(3),
- B(Ldar), R(closure),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kPushBlockContext), R(3), U8(2),
- B(PushContext), R(2),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(1), U8(0),
- B(Star), R(0),
- B(LdaSmi), U8(10),
- B(StaContextSlot), R(context), U8(4),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(2),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
- B(Star), R(1),
- B(Jump), U8(2),
- B(PopContext), R(2),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ B(LdaConstant), U8(0),
+ B(Star), R(3),
+ B(Ldar), R(closure),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kPushBlockContext), R(3), U8(2),
+ B(PushContext), R(2),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(1), U8(0),
+ B(Star), R(0),
+ /* 53 S> */ B(LdaSmi), U8(10),
+ /* 53 E> */ B(StaContextSlot), R(context), U8(4),
+ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(2),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(Star), R(1),
+ /* 88 S> */ B(Jump), U8(2),
+ B(PopContext), R(2),
+ B(LdaUndefined),
+ /* 103 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -165,60 +162,60 @@
parameter count: 1
bytecode array length: 131
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(2),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(StaContextSlot), R(context), U8(4),
- B(LdaConstant), U8(0),
- B(Star), R(4),
- B(Ldar), R(closure),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kPushBlockContext), R(4), U8(2),
- B(PushContext), R(3),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(1), U8(0),
- B(Star), R(0),
- B(LdaSmi), U8(2),
- B(StaContextSlot), R(context), U8(4),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(2),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
- B(Star), R(1),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(3),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
- B(JumpIfToBooleanFalse), U8(6),
- B(PopContext), R(3),
- B(Jump), U8(27),
- B(LdaSmi), U8(3),
- B(Star), R(4),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(3),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(5), U8(1),
- B(Ldar), R(4),
- B(StaContextSlot), R(context), U8(4),
- B(PopContext), R(3),
- B(LdaSmi), U8(4),
- B(Star), R(4),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(4),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(5), U8(1),
- B(Ldar), R(4),
- B(StaContextSlot), R(context), U8(4),
- B(LdaUndefined),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(2),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(StaContextSlot), R(context), U8(4),
+ B(LdaConstant), U8(0),
+ B(Star), R(4),
+ B(Ldar), R(closure),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kPushBlockContext), R(4), U8(2),
+ B(PushContext), R(3),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(1), U8(0),
+ B(Star), R(0),
+ /* 76 S> */ B(LdaSmi), U8(2),
+ /* 76 E> */ B(StaContextSlot), R(context), U8(4),
+ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(2),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
+ B(Star), R(1),
+ /* 118 S> */ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(3),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
+ B(JumpIfToBooleanFalse), U8(6),
+ /* 125 S> */ B(PopContext), R(3),
+ B(Jump), U8(27),
+ /* 142 S> */ B(LdaSmi), U8(3),
+ /* 144 E> */ B(Star), R(4),
+ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(3),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(5), U8(1),
+ B(Ldar), R(4),
+ B(StaContextSlot), R(context), U8(4),
+ B(PopContext), R(3),
+ /* 155 S> */ B(LdaSmi), U8(4),
+ /* 157 E> */ B(Star), R(4),
+ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(4),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(5), U8(1),
+ B(Ldar), R(4),
+ B(StaContextSlot), R(context), U8(4),
+ B(LdaUndefined),
+ /* 162 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/CallGlobal.golden b/test/cctest/interpreter/bytecode_expectations/CallGlobal.golden
index 04bc3a9..0d8624b 100644
--- a/test/cctest/interpreter/bytecode_expectations/CallGlobal.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CallGlobal.golden
@@ -18,13 +18,13 @@
parameter count: 1
bytecode array length: 15
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Star), R(1),
- B(LdaGlobal), U8(0), U8(3),
- B(Star), R(0),
- B(Call), R(0), R(1), U8(1), U8(1),
- B(Return),
+ /* 27 E> */ B(StackCheck),
+ /* 32 S> */ B(LdaUndefined),
+ B(Star), R(1),
+ B(LdaGlobal), U8(0), U8(3),
+ B(Star), R(0),
+ /* 39 E> */ B(Call), R(0), R(1), U8(1), U8(1),
+ /* 44 S> */ B(Return),
]
constant pool: [
"t",
@@ -42,19 +42,19 @@
parameter count: 1
bytecode array length: 27
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Star), R(1),
- B(LdaGlobal), U8(0), U8(3),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Star), R(2),
- B(LdaSmi), U8(2),
- B(Star), R(3),
- B(LdaSmi), U8(3),
- B(Star), R(4),
- B(Call), R(0), R(1), U8(4), U8(1),
- B(Return),
+ /* 34 E> */ B(StackCheck),
+ /* 39 S> */ B(LdaUndefined),
+ B(Star), R(1),
+ B(LdaGlobal), U8(0), U8(3),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(2),
+ B(Star), R(3),
+ B(LdaSmi), U8(3),
+ B(Star), R(4),
+ /* 46 E> */ B(Call), R(0), R(1), U8(4), U8(1),
+ /* 58 S> */ B(Return),
]
constant pool: [
"t",
diff --git a/test/cctest/interpreter/bytecode_expectations/CallLookupSlot.golden b/test/cctest/interpreter/bytecode_expectations/CallLookupSlot.golden
index 30b69d3..0ab5fcb 100644
--- a/test/cctest/interpreter/bytecode_expectations/CallLookupSlot.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CallLookupSlot.golden
@@ -11,41 +11,43 @@
snippet: "
g = function(){}; eval(''); return g();
"
-frame size: 9
+frame size: 10
parameter count: 1
-bytecode array length: 85
+bytecode array length: 89
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(Ldar), R(this),
- B(StaContextSlot), R(context), U8(4),
- B(CreateMappedArguments),
- B(StaContextSlot), R(context), U8(5),
- B(Ldar), R(new_target),
- B(StaContextSlot), R(context), U8(6),
- B(StackCheck),
- B(CreateClosure), U8(0), U8(0),
- B(StaLookupSlotSloppy), U8(1),
- B(LdaConstant), U8(2),
- B(Star), R(3),
- B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
- B(LdaConstant), U8(3),
- B(Star), R(3),
- B(Mov), R(1), R(4),
- B(Mov), R(3), R(5),
- B(Mov), R(closure), R(6),
- B(LdaZero),
- B(Star), R(7),
- B(LdaSmi), U8(30),
- B(Star), R(8),
- B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), U8(5),
- B(Star), R(1),
- B(Call), R(1), R(2), U8(2), U8(0),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
- B(Call), R(1), R(2), U8(1), U8(3),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(this),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateMappedArguments),
+ B(StaContextSlot), R(context), U8(5),
+ B(Ldar), R(new_target),
+ B(StaContextSlot), R(context), U8(6),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 36 E> */ B(StaLookupSlotSloppy), U8(1),
+ /* 52 S> */ B(LdaConstant), U8(2),
+ B(Star), R(3),
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
+ B(LdaConstant), U8(3),
+ B(Star), R(3),
+ B(Mov), R(1), R(4),
+ B(Mov), R(3), R(5),
+ B(Mov), R(closure), R(6),
+ B(LdaZero),
+ B(Star), R(7),
+ B(LdaSmi), U8(30),
+ B(Star), R(8),
+ B(LdaSmi), U8(52),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), U8(6),
+ B(Star), R(1),
+ /* 52 E> */ B(Call), R(1), R(2), U8(2), U8(0),
+ /* 62 S> */ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
+ /* 69 E> */ B(Call), R(1), R(2), U8(1), U8(3),
+ /* 74 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/CallNew.golden b/test/cctest/interpreter/bytecode_expectations/CallNew.golden
index 4952c73..79dd5c1 100644
--- a/test/cctest/interpreter/bytecode_expectations/CallNew.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CallNew.golden
@@ -18,11 +18,11 @@
parameter count: 1
bytecode array length: 11
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(2),
- B(Star), R(0),
- B(New), R(0), R(0), U8(0),
- B(Return),
+ /* 45 E> */ B(StackCheck),
+ /* 50 S> */ B(LdaGlobal), U8(0), U8(2),
+ B(Star), R(0),
+ /* 57 E> */ B(New), R(0), R(0), U8(0),
+ /* 68 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -40,14 +40,14 @@
parameter count: 1
bytecode array length: 17
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(2),
- B(Star), R(0),
- B(LdaSmi), U8(3),
- B(Star), R(1),
- B(Ldar), R(0),
- B(New), R(0), R(1), U8(1),
- B(Return),
+ /* 58 E> */ B(StackCheck),
+ /* 63 S> */ B(LdaGlobal), U8(0), U8(2),
+ B(Star), R(0),
+ B(LdaSmi), U8(3),
+ B(Star), R(1),
+ /* 70 E> */ B(Ldar), R(0),
+ B(New), R(0), R(1), U8(1),
+ /* 82 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -70,18 +70,18 @@
parameter count: 1
bytecode array length: 25
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(2),
- B(Star), R(0),
- B(LdaSmi), U8(3),
- B(Star), R(1),
- B(LdaSmi), U8(4),
- B(Star), R(2),
- B(LdaSmi), U8(5),
- B(Star), R(3),
- B(Ldar), R(0),
- B(New), R(0), R(1), U8(3),
- B(Return),
+ /* 100 E> */ B(StackCheck),
+ /* 105 S> */ B(LdaGlobal), U8(0), U8(2),
+ B(Star), R(0),
+ B(LdaSmi), U8(3),
+ B(Star), R(1),
+ B(LdaSmi), U8(4),
+ B(Star), R(2),
+ B(LdaSmi), U8(5),
+ B(Star), R(3),
+ /* 112 E> */ B(Ldar), R(0),
+ B(New), R(0), R(1), U8(3),
+ /* 130 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/CallRuntime.golden b/test/cctest/interpreter/bytecode_expectations/CallRuntime.golden
index ec10e67..69edecc 100644
--- a/test/cctest/interpreter/bytecode_expectations/CallRuntime.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CallRuntime.golden
@@ -17,10 +17,10 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(CallRuntime), U16(Runtime::kTheHole), R(0), U8(0),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(CallRuntime), U16(Runtime::kTheHole), R(0), U8(0),
+ B(LdaUndefined),
+ /* 26 S> */ B(Return),
]
constant pool: [
]
@@ -36,11 +36,11 @@
parameter count: 2
bytecode array length: 11
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(CallRuntime), U16(Runtime::kIsArray), R(0), U8(1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 16 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(CallRuntime), U16(Runtime::kIsArray), R(0), U8(1),
+ /* 35 S> */ B(Return),
]
constant pool: [
]
@@ -56,13 +56,13 @@
parameter count: 1
bytecode array length: 15
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(CallRuntime), U16(Runtime::kAdd), R(0), U8(2),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(LdaSmi), U8(1),
+ B(Star), R(0),
+ B(LdaSmi), U8(2),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kAdd), R(0), U8(2),
+ /* 33 S> */ B(Return),
]
constant pool: [
]
@@ -78,13 +78,13 @@
parameter count: 1
bytecode array length: 15
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Star), R(0),
- B(CreateArrayLiteral), U8(0), U8(0), U8(3),
- B(Star), R(1),
- B(CallJSRuntime), U8(115), R(0), U8(2),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(LdaUndefined),
+ B(Star), R(0),
+ B(CreateArrayLiteral), U8(0), U8(0), U8(3),
+ B(Star), R(1),
+ B(CallJSRuntime), U8(122), R(0), U8(2),
+ /* 44 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/ClassAndSuperClass.golden b/test/cctest/interpreter/bytecode_expectations/ClassAndSuperClass.golden
index 6869c5b..abe5b29 100644
--- a/test/cctest/interpreter/bytecode_expectations/ClassAndSuperClass.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ClassAndSuperClass.golden
@@ -26,30 +26,30 @@
parameter count: 1
bytecode array length: 57
bytecodes: [
- B(Ldar), R(closure),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(this),
- B(Star), R(3),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(6),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(6), U8(1),
- B(Star), R(6),
- B(LdaConstant), U8(1),
- B(KeyedLoadIC), R(6), U8(3),
- B(Star), R(4),
- B(LdaConstant), U8(2),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kLoadFromSuper), R(3), U8(3),
- B(Mov), R(3), R(2),
- B(Star), R(1),
- B(Call), R(1), R(2), U8(1), U8(1),
- B(Star), R(3),
- B(LdaSmi), U8(1),
- B(Add), R(3),
- B(Return),
+ B(Ldar), R(closure),
+ B(Star), R(0),
+ /* 99 E> */ B(StackCheck),
+ /* 104 S> */ B(Ldar), R(this),
+ B(Star), R(3),
+ /* 111 E> */ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(6), U8(1),
+ B(Star), R(6),
+ /* 111 E> */ B(LdaConstant), U8(1),
+ B(KeyedLoadIC), R(6), U8(3),
+ B(Star), R(4),
+ B(LdaConstant), U8(2),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kLoadFromSuper), R(3), U8(3),
+ B(Mov), R(3), R(2),
+ B(Star), R(1),
+ /* 117 E> */ B(Call), R(1), R(2), U8(1), U8(1),
+ B(Star), R(3),
+ B(LdaSmi), U8(1),
+ B(Add), R(3),
+ /* 131 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -78,40 +78,40 @@
parameter count: 1
bytecode array length: 80
bytecodes: [
- B(Ldar), R(closure),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(this),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(5), U8(1),
- B(Star), R(5),
- B(LdaConstant), U8(1),
- B(KeyedLoadIC), R(5), U8(1),
- B(Star), R(2),
- B(LdaConstant), U8(2),
- B(Star), R(3),
- B(LdaSmi), U8(2),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kStoreToSuper_Strict), R(1), U8(4),
- B(Ldar), R(this),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
- B(Star), R(4),
- B(LdaConstant), U8(1),
- B(KeyedLoadIC), R(4), U8(3),
- B(Star), R(2),
- B(LdaConstant), U8(2),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kLoadFromSuper), R(1), U8(3),
- B(Return),
+ B(Ldar), R(closure),
+ B(Star), R(0),
+ /* 125 E> */ B(StackCheck),
+ /* 130 S> */ B(Ldar), R(this),
+ B(Star), R(1),
+ /* 130 E> */ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(5), U8(1),
+ B(Star), R(5),
+ /* 130 E> */ B(LdaConstant), U8(1),
+ B(KeyedLoadIC), R(5), U8(1),
+ B(Star), R(2),
+ B(LdaConstant), U8(2),
+ B(Star), R(3),
+ B(LdaSmi), U8(2),
+ /* 138 E> */ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kStoreToSuper_Strict), R(1), U8(4),
+ /* 143 S> */ B(Ldar), R(this),
+ B(Star), R(1),
+ /* 150 E> */ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
+ B(Star), R(4),
+ /* 150 E> */ B(LdaConstant), U8(1),
+ B(KeyedLoadIC), R(4), U8(3),
+ B(Star), R(2),
+ B(LdaConstant), U8(2),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kLoadFromSuper), R(1), U8(3),
+ /* 159 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -138,49 +138,49 @@
parameter count: 1
bytecode array length: 106
bytecodes: [
- B(Ldar), R(closure),
- B(Star), R(1),
- B(Ldar), R(new_target),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(1),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::k_GetSuperConstructor), R(2), U8(1),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(3),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(1),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
- B(New), R(2), R(3), U8(1),
- B(Star), R(2),
- B(Ldar), R(this),
- B(JumpIfNotHole), U8(4),
- B(Jump), U8(11),
- B(LdaConstant), U8(2),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
- B(Ldar), R(2),
- B(Star), R(this),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(2),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
- B(Star), R(2),
- B(LdaSmi), U8(2),
- B(StoreICStrict), R(2), U8(3), U8(4),
- B(Ldar), R(this),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(2),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
- B(Return),
+ B(Ldar), R(closure),
+ B(Star), R(1),
+ B(Ldar), R(new_target),
+ B(Star), R(0),
+ /* 113 E> */ B(StackCheck),
+ /* 118 S> */ B(Ldar), R(1),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::k_GetSuperConstructor), R(2), U8(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Star), R(3),
+ /* 118 E> */ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(1),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
+ /* 118 E> */ B(New), R(2), R(3), U8(1),
+ /* 118 E> */ B(Star), R(2),
+ B(Ldar), R(this),
+ B(JumpIfNotHole), U8(4),
+ B(Jump), U8(11),
+ B(LdaConstant), U8(2),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(Ldar), R(2),
+ B(Star), R(this),
+ /* 128 S> */ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(2),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(2),
+ /* 136 E> */ B(StoreICStrict), R(2), U8(3), U8(4),
+ B(Ldar), R(this),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(2),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ /* 141 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -208,47 +208,47 @@
parameter count: 1
bytecode array length: 102
bytecodes: [
- B(Ldar), R(closure),
- B(Star), R(1),
- B(Ldar), R(new_target),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(1),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::k_GetSuperConstructor), R(2), U8(1),
- B(Star), R(2),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
- B(New), R(2), R(0), U8(0),
- B(Star), R(2),
- B(Ldar), R(this),
- B(JumpIfNotHole), U8(4),
- B(Jump), U8(11),
- B(LdaConstant), U8(2),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
- B(Ldar), R(2),
- B(Star), R(this),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(2),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
- B(Star), R(2),
- B(LdaSmi), U8(2),
- B(StoreICStrict), R(2), U8(3), U8(4),
- B(Ldar), R(this),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(2),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
- B(Return),
+ B(Ldar), R(closure),
+ B(Star), R(1),
+ B(Ldar), R(new_target),
+ B(Star), R(0),
+ /* 112 E> */ B(StackCheck),
+ /* 117 S> */ B(Ldar), R(1),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::k_GetSuperConstructor), R(2), U8(1),
+ B(Star), R(2),
+ /* 117 E> */ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ /* 117 E> */ B(New), R(2), R(0), U8(0),
+ /* 117 E> */ B(Star), R(2),
+ B(Ldar), R(this),
+ B(JumpIfNotHole), U8(4),
+ B(Jump), U8(11),
+ B(LdaConstant), U8(2),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(Ldar), R(2),
+ B(Star), R(this),
+ /* 126 S> */ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(2),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(2),
+ /* 134 E> */ B(StoreICStrict), R(2), U8(3), U8(4),
+ B(Ldar), R(this),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(2),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ /* 139 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/ClassDeclarations.golden b/test/cctest/interpreter/bytecode_expectations/ClassDeclarations.golden
index db42c50..6947a27 100644
--- a/test/cctest/interpreter/bytecode_expectations/ClassDeclarations.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ClassDeclarations.golden
@@ -18,38 +18,38 @@
parameter count: 1
bytecode array length: 73
bytecodes: [
- B(LdaTheHole),
- B(Star), R(1),
- B(StackCheck),
- B(LdaTheHole),
- B(Star), R(0),
- B(LdaTheHole),
- B(Star), R(2),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(3),
- B(LdaSmi), U8(34),
- B(Star), R(4),
- B(Wide), B(LdaSmi), U16(148),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(4),
- B(Star), R(2),
- B(LoadIC), R(2), U8(1), U8(1),
- B(Star), R(3),
- B(Mov), R(3), R(4),
- B(LdaConstant), U8(2),
- B(Star), R(5),
- B(CreateClosure), U8(3), U8(0),
- B(Star), R(6),
- B(LdaSmi), U8(2),
- B(Star), R(7),
- B(LdaZero),
- B(Star), R(8),
- B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(4), U8(5),
- B(CallRuntime), U16(Runtime::kFinalizeClassDefinition), R(2), U8(2),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaUndefined),
- B(Return),
+ B(LdaTheHole),
+ B(Star), R(1),
+ /* 30 E> */ B(StackCheck),
+ B(LdaTheHole),
+ B(Star), R(0),
+ B(LdaTheHole),
+ B(Star), R(2),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(3),
+ B(LdaSmi), U8(34),
+ B(Star), R(4),
+ B(Wide), B(LdaSmi), U16(148),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(4),
+ B(Star), R(2),
+ B(LoadIC), R(2), U8(1), U8(1),
+ B(Star), R(3),
+ B(Mov), R(3), R(4),
+ B(LdaConstant), U8(2),
+ B(Star), R(5),
+ B(CreateClosure), U8(3), U8(0),
+ B(Star), R(6),
+ B(LdaSmi), U8(2),
+ B(Star), R(7),
+ B(LdaZero),
+ B(Star), R(8),
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(4), U8(5),
+ B(CallRuntime), U16(Runtime::kToFastProperties), R(2), U8(1),
+ B(Star), R(0),
+ /* 34 E> */ B(Star), R(1),
+ B(LdaUndefined),
+ /* 149 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -71,38 +71,38 @@
parameter count: 1
bytecode array length: 73
bytecodes: [
- B(LdaTheHole),
- B(Star), R(1),
- B(StackCheck),
- B(LdaTheHole),
- B(Star), R(0),
- B(LdaTheHole),
- B(Star), R(2),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(3),
- B(LdaSmi), U8(34),
- B(Star), R(4),
- B(Wide), B(LdaSmi), U16(148),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(4),
- B(Star), R(2),
- B(LoadIC), R(2), U8(1), U8(1),
- B(Star), R(3),
- B(Mov), R(3), R(4),
- B(LdaConstant), U8(2),
- B(Star), R(5),
- B(CreateClosure), U8(3), U8(0),
- B(Star), R(6),
- B(LdaSmi), U8(2),
- B(Star), R(7),
- B(LdaZero),
- B(Star), R(8),
- B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(4), U8(5),
- B(CallRuntime), U16(Runtime::kFinalizeClassDefinition), R(2), U8(2),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaUndefined),
- B(Return),
+ B(LdaTheHole),
+ B(Star), R(1),
+ /* 30 E> */ B(StackCheck),
+ B(LdaTheHole),
+ B(Star), R(0),
+ B(LdaTheHole),
+ B(Star), R(2),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(3),
+ B(LdaSmi), U8(34),
+ B(Star), R(4),
+ B(Wide), B(LdaSmi), U16(148),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kDefineClass), R(2), U8(4),
+ B(Star), R(2),
+ B(LoadIC), R(2), U8(1), U8(1),
+ B(Star), R(3),
+ B(Mov), R(3), R(4),
+ B(LdaConstant), U8(2),
+ B(Star), R(5),
+ B(CreateClosure), U8(3), U8(0),
+ B(Star), R(6),
+ B(LdaSmi), U8(2),
+ B(Star), R(7),
+ B(LdaZero),
+ B(Star), R(8),
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(4), U8(5),
+ B(CallRuntime), U16(Runtime::kToFastProperties), R(2), U8(1),
+ B(Star), R(0),
+ /* 34 E> */ B(Star), R(1),
+ B(LdaUndefined),
+ /* 149 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -126,58 +126,58 @@
parameter count: 1
bytecode array length: 127
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(2),
- B(LdaTheHole),
- B(Star), R(1),
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(StaContextSlot), R(context), U8(4),
- B(LdaConstant), U8(1),
- B(StaContextSlot), R(context), U8(5),
- B(LdaTheHole),
- B(Star), R(0),
- B(LdaTheHole),
- B(Star), R(3),
- B(CreateClosure), U8(2), U8(0),
- B(Star), R(4),
- B(LdaSmi), U8(62),
- B(Star), R(5),
- B(Wide), B(LdaSmi), U16(128),
- B(Star), R(6),
- B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
- B(Star), R(3),
- B(LoadIC), R(3), U8(3), U8(1),
- B(Star), R(4),
- B(Mov), R(4), R(5),
- B(LdaContextSlot), R(context), U8(4),
- B(ToName),
- B(Star), R(6),
- B(CreateClosure), U8(4), U8(0),
- B(Star), R(7),
- B(LdaSmi), U8(2),
- B(Star), R(8),
- B(LdaSmi), U8(1),
- B(Star), R(9),
- B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(5), U8(5),
- B(Mov), R(3), R(5),
- B(LdaContextSlot), R(context), U8(5),
- B(ToName),
- B(Star), R(6),
- B(LdaConstant), U8(3),
- B(TestEqualStrict), R(6),
- B(JumpIfFalse), U8(7),
- B(CallRuntime), U16(Runtime::kThrowStaticPrototypeError), R(0), U8(0),
- B(CreateClosure), U8(5), U8(0),
- B(Star), R(7),
- B(LdaSmi), U8(1),
- B(Star), R(9),
- B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(5), U8(5),
- B(CallRuntime), U16(Runtime::kFinalizeClassDefinition), R(3), U8(2),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaUndefined),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(2),
+ B(LdaTheHole),
+ B(Star), R(1),
+ /* 30 E> */ B(StackCheck),
+ /* 43 S> */ B(LdaConstant), U8(0),
+ /* 43 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 57 S> */ B(LdaConstant), U8(1),
+ /* 57 E> */ B(StaContextSlot), R(context), U8(5),
+ B(LdaTheHole),
+ B(Star), R(0),
+ B(LdaTheHole),
+ B(Star), R(3),
+ B(CreateClosure), U8(2), U8(0),
+ B(Star), R(4),
+ B(LdaSmi), U8(62),
+ B(Star), R(5),
+ B(Wide), B(LdaSmi), U16(128),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
+ B(Star), R(3),
+ B(LoadIC), R(3), U8(3), U8(1),
+ B(Star), R(4),
+ B(Mov), R(4), R(5),
+ /* 75 E> */ B(LdaContextSlot), R(context), U8(4),
+ B(ToName),
+ B(Star), R(6),
+ B(CreateClosure), U8(4), U8(0),
+ B(Star), R(7),
+ B(LdaSmi), U8(2),
+ B(Star), R(8),
+ B(LdaSmi), U8(1),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(5), U8(5),
+ B(Mov), R(3), R(5),
+ /* 106 E> */ B(LdaContextSlot), R(context), U8(5),
+ B(ToName),
+ B(Star), R(6),
+ B(LdaConstant), U8(3),
+ B(TestEqualStrict), R(6),
+ B(JumpIfFalse), U8(7),
+ B(CallRuntime), U16(Runtime::kThrowStaticPrototypeError), R(0), U8(0),
+ B(CreateClosure), U8(5), U8(0),
+ B(Star), R(7),
+ B(LdaSmi), U8(1),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(5), U8(5),
+ B(CallRuntime), U16(Runtime::kToFastProperties), R(3), U8(1),
+ B(Star), R(0),
+ /* 62 E> */ B(Star), R(1),
+ B(LdaUndefined),
+ /* 129 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -196,41 +196,41 @@
class C { constructor() { count++; }}
return new C();
"
-frame size: 10
+frame size: 7
parameter count: 1
bytecode array length: 74
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(2),
- B(LdaTheHole),
- B(Star), R(1),
- B(StackCheck),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(4),
- B(LdaTheHole),
- B(Star), R(0),
- B(LdaTheHole),
- B(Star), R(3),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(4),
- B(LdaSmi), U8(49),
- B(Star), R(5),
- B(LdaSmi), U8(86),
- B(Star), R(6),
- B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
- B(Star), R(3),
- B(LoadIC), R(3), U8(1), U8(1),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kFinalizeClassDefinition), R(3), U8(2),
- B(Star), R(0),
- B(Star), R(1),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(2),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
- B(Star), R(3),
- B(New), R(3), R(0), U8(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(2),
+ B(LdaTheHole),
+ B(Star), R(1),
+ /* 30 E> */ B(StackCheck),
+ /* 46 S> */ B(LdaZero),
+ /* 46 E> */ B(StaContextSlot), R(context), U8(4),
+ B(LdaTheHole),
+ B(Star), R(0),
+ B(LdaTheHole),
+ B(Star), R(3),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(4),
+ B(LdaSmi), U8(49),
+ B(Star), R(5),
+ B(LdaSmi), U8(86),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),
+ B(Star), R(3),
+ B(LoadIC), R(3), U8(1), U8(1),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kToFastProperties), R(3), U8(1),
+ B(Star), R(0),
+ /* 49 E> */ B(Star), R(1),
+ /* 87 S> */ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(2),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(4), U8(1),
+ B(Star), R(3),
+ /* 94 E> */ B(New), R(3), R(0), U8(0),
+ /* 103 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/CompoundExpressions.golden b/test/cctest/interpreter/bytecode_expectations/CompoundExpressions.golden
index ccabedc..374a203 100644
--- a/test/cctest/interpreter/bytecode_expectations/CompoundExpressions.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CompoundExpressions.golden
@@ -15,15 +15,15 @@
parameter count: 1
bytecode array length: 15
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Add), R(1),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ B(Add), R(1),
+ /* 47 E> */ B(Star), R(0),
+ B(LdaUndefined),
+ /* 53 S> */ B(Return),
]
constant pool: [
]
@@ -38,15 +38,15 @@
parameter count: 1
bytecode array length: 15
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Div), R(1),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ B(Div), R(1),
+ /* 47 E> */ B(Star), R(0),
+ B(LdaUndefined),
+ /* 53 S> */ B(Return),
]
constant pool: [
]
@@ -61,18 +61,18 @@
parameter count: 1
bytecode array length: 27
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(1), U8(1),
- B(Star), R(2),
- B(LdaSmi), U8(2),
- B(Mul), R(2),
- B(StoreICSloppy), R(1), U8(1), U8(3),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 54 S> */ B(Star), R(1),
+ B(LoadIC), R(1), U8(1), U8(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(2),
+ B(Mul), R(2),
+ /* 61 E> */ B(StoreICSloppy), R(1), U8(1), U8(3),
+ B(LdaUndefined),
+ /* 67 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -89,20 +89,20 @@
parameter count: 1
bytecode array length: 30
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Star), R(2),
- B(KeyedLoadIC), R(1), U8(1),
- B(Star), R(3),
- B(LdaSmi), U8(2),
- B(BitwiseXor), R(3),
- B(KeyedStoreICSloppy), R(1), R(2), U8(3),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 52 S> */ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Star), R(2),
+ B(KeyedLoadIC), R(1), U8(1),
+ B(Star), R(3),
+ B(LdaSmi), U8(2),
+ B(BitwiseXor), R(3),
+ /* 57 E> */ B(KeyedStoreICSloppy), R(1), R(2), U8(3),
+ B(LdaUndefined),
+ /* 63 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -118,19 +118,19 @@
parameter count: 1
bytecode array length: 30
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(1),
- B(LdaSmi), U8(24),
- B(BitwiseOr), R(1),
- B(StaContextSlot), R(context), U8(4),
- B(LdaUndefined),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 45 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 75 S> */ B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(1),
+ B(LdaSmi), U8(24),
+ B(BitwiseOr), R(1),
+ /* 77 E> */ B(StaContextSlot), R(context), U8(4),
+ B(LdaUndefined),
+ /* 84 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/Conditional.golden b/test/cctest/interpreter/bytecode_expectations/Conditional.golden
index 17327a5..e051d45 100644
--- a/test/cctest/interpreter/bytecode_expectations/Conditional.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Conditional.golden
@@ -15,13 +15,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(JumpIfToBooleanFalse), U8(6),
- B(LdaSmi), U8(2),
- B(Jump), U8(4),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaSmi), U8(1),
+ B(JumpIfToBooleanFalse), U8(6),
+ B(LdaSmi), U8(2),
+ B(Jump), U8(4),
+ B(LdaSmi), U8(3),
+ /* 52 S> */ B(Return),
]
constant pool: [
]
@@ -36,17 +36,17 @@
parameter count: 1
bytecode array length: 20
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(JumpIfToBooleanFalse), U8(14),
- B(LdaSmi), U8(2),
- B(JumpIfToBooleanFalse), U8(6),
- B(LdaSmi), U8(3),
- B(Jump), U8(4),
- B(LdaSmi), U8(4),
- B(Jump), U8(4),
- B(LdaSmi), U8(5),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaSmi), U8(1),
+ B(JumpIfToBooleanFalse), U8(14),
+ B(LdaSmi), U8(2),
+ B(JumpIfToBooleanFalse), U8(6),
+ B(LdaSmi), U8(3),
+ B(Jump), U8(4),
+ B(LdaSmi), U8(4),
+ B(Jump), U8(4),
+ B(LdaSmi), U8(5),
+ /* 60 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/ConstVariable.golden b/test/cctest/interpreter/bytecode_expectations/ConstVariable.golden
index d3fb484..505d3e8 100644
--- a/test/cctest/interpreter/bytecode_expectations/ConstVariable.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ConstVariable.golden
@@ -15,13 +15,13 @@
parameter count: 1
bytecode array length: 10
bytecodes: [
- B(LdaTheHole),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ B(LdaTheHole),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 44 S> */ B(LdaSmi), U8(10),
+ /* 44 E> */ B(Star), R(0),
+ B(LdaUndefined),
+ /* 48 S> */ B(Return),
]
constant pool: [
]
@@ -36,16 +36,16 @@
parameter count: 1
bytecode array length: 20
bytecodes: [
- B(LdaTheHole),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(1),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(1), U8(1),
- B(Return),
+ B(LdaTheHole),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 44 S> */ B(LdaSmi), U8(10),
+ /* 44 E> */ B(Star), R(0),
+ /* 48 S> */ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(1), U8(1),
+ /* 58 S> */ B(Return),
]
constant pool: [
"x",
@@ -61,21 +61,21 @@
parameter count: 1
bytecode array length: 32
bytecodes: [
- B(LdaTheHole),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(20),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
- B(CallRuntime), U16(Runtime::kThrowConstAssignError), R(0), U8(0),
- B(Ldar), R(1),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ B(LdaTheHole),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 48 S> */ B(LdaSmi), U8(20),
+ /* 48 E> */ B(Star), R(1),
+ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ B(CallRuntime), U16(Runtime::kThrowConstAssignError), R(0), U8(0),
+ B(Ldar), R(1),
+ B(Star), R(0),
+ /* 48 E> */ B(LdaUndefined),
+ /* 55 S> */ B(Return),
]
constant pool: [
"x",
@@ -91,23 +91,23 @@
parameter count: 1
bytecode array length: 36
bytecodes: [
- B(LdaTheHole),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(LdaSmi), U8(20),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
- B(CallRuntime), U16(Runtime::kThrowConstAssignError), R(0), U8(0),
- B(Ldar), R(1),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ B(LdaTheHole),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 44 S> */ B(LdaSmi), U8(10),
+ /* 44 E> */ B(Star), R(0),
+ /* 48 S> */ B(LdaSmi), U8(20),
+ /* 50 E> */ B(Star), R(1),
+ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ B(CallRuntime), U16(Runtime::kThrowConstAssignError), R(0), U8(0),
+ B(Ldar), R(1),
+ B(Star), R(0),
+ B(LdaUndefined),
+ /* 56 S> */ B(Return),
]
constant pool: [
"x",
diff --git a/test/cctest/interpreter/bytecode_expectations/ConstVariableContextSlot.golden b/test/cctest/interpreter/bytecode_expectations/ConstVariableContextSlot.golden
index 3b445c1..6087101 100644
--- a/test/cctest/interpreter/bytecode_expectations/ConstVariableContextSlot.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ConstVariableContextSlot.golden
@@ -15,17 +15,17 @@
parameter count: 1
bytecode array length: 24
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(StaContextSlot), R(context), U8(4),
- B(LdaUndefined),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 44 S> */ B(LdaSmi), U8(10),
+ /* 44 E> */ B(StaContextSlot), R(context), U8(4),
+ B(LdaUndefined),
+ /* 74 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -41,21 +41,21 @@
parameter count: 1
bytecode array length: 37
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(StaContextSlot), R(context), U8(4),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(1),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 44 S> */ B(LdaSmi), U8(10),
+ /* 44 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 74 S> */ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(1),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ /* 84 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -72,26 +72,26 @@
parameter count: 1
bytecode array length: 50
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(20),
- B(Star), R(2),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
- B(CallRuntime), U16(Runtime::kThrowConstAssignError), R(0), U8(0),
- B(Ldar), R(2),
- B(StaContextSlot), R(context), U8(4),
- B(StaContextSlot), R(context), U8(4),
- B(LdaUndefined),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 47 S> */ B(LdaSmi), U8(20),
+ /* 47 E> */ B(Star), R(2),
+ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(CallRuntime), U16(Runtime::kThrowConstAssignError), R(0), U8(0),
+ B(Ldar), R(2),
+ B(StaContextSlot), R(context), U8(4),
+ /* 47 E> */ B(StaContextSlot), R(context), U8(4),
+ B(LdaUndefined),
+ /* 80 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -108,27 +108,27 @@
parameter count: 1
bytecode array length: 52
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(StaContextSlot), R(context), U8(4),
- B(LdaSmi), U8(20),
- B(Star), R(2),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
- B(CallRuntime), U16(Runtime::kThrowConstAssignError), R(0), U8(0),
- B(Ldar), R(2),
- B(StaContextSlot), R(context), U8(4),
- B(LdaUndefined),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 44 S> */ B(LdaSmi), U8(10),
+ /* 44 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 48 S> */ B(LdaSmi), U8(20),
+ /* 50 E> */ B(Star), R(2),
+ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(CallRuntime), U16(Runtime::kThrowConstAssignError), R(0), U8(0),
+ B(Ldar), R(2),
+ B(StaContextSlot), R(context), U8(4),
+ B(LdaUndefined),
+ /* 82 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/ContextParameters.golden b/test/cctest/interpreter/bytecode_expectations/ContextParameters.golden
index fb74600..72b731e 100644
--- a/test/cctest/interpreter/bytecode_expectations/ContextParameters.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ContextParameters.golden
@@ -17,13 +17,13 @@
parameter count: 2
bytecode array length: 17
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(Ldar), R(arg0),
- B(StaContextSlot), R(context), U8(4),
- B(StackCheck),
- B(CreateClosure), U8(0), U8(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(arg0),
+ B(StaContextSlot), R(context), U8(4),
+ /* 10 E> */ B(StackCheck),
+ /* 19 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 52 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -40,15 +40,15 @@
parameter count: 2
bytecode array length: 22
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(Ldar), R(arg0),
- B(StaContextSlot), R(context), U8(4),
- B(StackCheck),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(LdaContextSlot), R(context), U8(4),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(Ldar), R(arg0),
+ B(StaContextSlot), R(context), U8(4),
+ /* 10 E> */ B(StackCheck),
+ /* 27 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 27 E> */ B(Star), R(0),
+ /* 53 S> */ B(LdaContextSlot), R(context), U8(4),
+ /* 66 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -65,15 +65,15 @@
parameter count: 5
bytecode array length: 22
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(Ldar), R(arg0),
- B(StaContextSlot), R(context), U8(5),
- B(Ldar), R(arg2),
- B(StaContextSlot), R(context), U8(4),
- B(StackCheck),
- B(CreateClosure), U8(0), U8(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(arg0),
+ B(StaContextSlot), R(context), U8(5),
+ B(Ldar), R(arg2),
+ B(StaContextSlot), R(context), U8(4),
+ /* 10 E> */ B(StackCheck),
+ /* 29 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 61 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -90,13 +90,13 @@
parameter count: 1
bytecode array length: 17
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(StackCheck),
- B(Ldar), R(this),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ /* 10 E> */ B(StackCheck),
+ /* 26 S> */ B(Ldar), R(this),
+ /* 26 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 32 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 65 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/ContextVariables.golden b/test/cctest/interpreter/bytecode_expectations/ContextVariables.golden
index b86e22b..ac5c042 100644
--- a/test/cctest/interpreter/bytecode_expectations/ContextVariables.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ContextVariables.golden
@@ -15,11 +15,11 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(StackCheck),
- B(CreateClosure), U8(0), U8(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 41 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 71 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -35,13 +35,13 @@
parameter count: 1
bytecode array length: 17
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 45 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 75 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -57,15 +57,15 @@
parameter count: 1
bytecode array length: 22
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(StaContextSlot), R(context), U8(4),
- B(LdaSmi), U8(2),
- B(StaContextSlot), R(context), U8(5),
- B(CreateClosure), U8(0), U8(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 53 S> */ B(LdaSmi), U8(2),
+ /* 53 E> */ B(StaContextSlot), R(context), U8(5),
+ /* 56 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 92 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -81,16 +81,16 @@
parameter count: 1
bytecode array length: 25
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(StackCheck),
- B(LdaUndefined),
- B(Star), R(2),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(1),
- B(Call), R(1), R(2), U8(1), U8(1),
- B(LdaContextSlot), R(context), U8(4),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 41 S> */ B(LdaUndefined),
+ B(Star), R(2),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(1),
+ /* 64 E> */ B(Call), R(1), R(2), U8(1), U8(1),
+ /* 68 S> */ B(LdaContextSlot), R(context), U8(4),
+ /* 78 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -108,26 +108,26 @@
parameter count: 1
bytecode array length: 47
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(StaContextSlot), R(context), U8(4),
- B(LdaConstant), U8(0),
- B(Star), R(2),
- B(Ldar), R(closure),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kPushBlockContext), R(2), U8(2),
- B(PushContext), R(1),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(LdaSmi), U8(2),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(1), U8(0),
- B(PopContext), R(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ /* 30 E> */ B(StackCheck),
+ /* 56 S> */ B(LdaSmi), U8(1),
+ /* 56 E> */ B(StaContextSlot), R(context), U8(4),
+ B(LdaConstant), U8(0),
+ B(Star), R(2),
+ B(Ldar), R(closure),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kPushBlockContext), R(2), U8(2),
+ B(PushContext), R(1),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ /* 69 S> */ B(LdaSmi), U8(2),
+ /* 69 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 72 S> */ B(CreateClosure), U8(1), U8(0),
+ B(PopContext), R(0),
+ /* 104 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -396,522 +396,522 @@
parameter count: 1
bytecode array length: 1046
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(Ldar), R(this),
- B(StaContextSlot), R(context), U8(4),
- B(CreateUnmappedArguments),
- B(StaContextSlot), R(context), U8(5),
- B(Ldar), R(new_target),
- B(StaContextSlot), R(context), U8(6),
- B(StackCheck),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(7),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(8),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(9),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(10),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(11),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(12),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(13),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(14),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(15),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(16),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(17),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(18),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(19),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(20),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(21),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(22),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(23),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(24),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(25),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(26),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(27),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(28),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(29),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(30),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(31),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(32),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(33),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(34),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(35),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(36),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(37),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(38),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(39),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(40),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(41),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(42),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(43),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(44),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(45),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(46),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(47),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(48),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(49),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(50),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(51),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(52),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(53),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(54),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(55),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(56),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(57),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(58),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(59),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(60),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(61),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(62),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(63),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(64),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(65),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(66),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(67),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(68),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(69),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(70),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(71),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(72),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(73),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(74),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(75),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(76),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(77),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(78),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(79),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(80),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(81),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(82),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(83),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(84),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(85),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(86),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(87),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(88),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(89),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(90),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(91),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(92),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(93),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(94),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(95),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(96),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(97),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(98),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(99),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(100),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(101),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(102),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(103),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(104),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(105),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(106),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(107),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(108),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(109),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(110),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(111),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(112),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(113),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(114),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(115),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(116),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(117),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(118),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(119),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(120),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(121),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(122),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(123),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(124),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(125),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(126),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(127),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(128),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(129),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(130),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(131),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(132),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(133),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(134),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(135),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(136),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(137),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(138),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(139),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(140),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(141),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(142),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(143),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(144),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(145),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(146),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(147),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(148),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(149),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(150),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(151),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(152),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(153),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(154),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(155),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(156),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(157),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(158),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(159),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(160),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(161),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(162),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(163),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(164),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(165),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(166),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(167),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(168),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(169),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(170),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(171),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(172),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(173),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(174),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(175),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(176),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(177),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(178),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(179),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(180),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(181),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(182),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(183),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(184),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(185),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(186),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(187),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(188),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(189),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(190),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(191),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(192),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(193),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(194),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(195),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(196),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(197),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(198),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(199),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(200),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(201),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(202),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(203),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(204),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(205),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(206),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(207),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(208),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(209),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(210),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(211),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(212),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(213),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(214),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(215),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(216),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(217),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(218),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(219),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(220),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(221),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(222),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(223),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(224),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(225),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(226),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(227),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(228),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(229),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(230),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(231),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(232),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(233),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(234),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(235),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(236),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(237),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(238),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(239),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(240),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(241),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(242),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(243),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(244),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(245),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(246),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(247),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(248),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(249),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(250),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(251),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(252),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(253),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(254),
- B(LdaZero),
- B(StaContextSlot), R(context), U8(255),
- B(LdaUndefined),
- B(Star), R(2),
- B(LdaGlobal), U8(0), U8(1),
- B(Star), R(1),
- B(Call), R(1), R(2), U8(1), U8(0),
- B(LdaSmi), U8(100),
- B(Wide), B(StaContextSlot), R16(context), U16(256),
- B(Wide), B(LdaContextSlot), R16(context), U16(256),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(this),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateUnmappedArguments),
+ B(StaContextSlot), R(context), U8(5),
+ B(Ldar), R(new_target),
+ B(StaContextSlot), R(context), U8(6),
+ /* 30 E> */ B(StackCheck),
+ /* 57 S> */ B(LdaZero),
+ /* 57 E> */ B(StaContextSlot), R(context), U8(7),
+ /* 69 S> */ B(LdaZero),
+ /* 69 E> */ B(StaContextSlot), R(context), U8(8),
+ /* 81 S> */ B(LdaZero),
+ /* 81 E> */ B(StaContextSlot), R(context), U8(9),
+ /* 93 S> */ B(LdaZero),
+ /* 93 E> */ B(StaContextSlot), R(context), U8(10),
+ /* 105 S> */ B(LdaZero),
+ /* 105 E> */ B(StaContextSlot), R(context), U8(11),
+ /* 117 S> */ B(LdaZero),
+ /* 117 E> */ B(StaContextSlot), R(context), U8(12),
+ /* 129 S> */ B(LdaZero),
+ /* 129 E> */ B(StaContextSlot), R(context), U8(13),
+ /* 141 S> */ B(LdaZero),
+ /* 141 E> */ B(StaContextSlot), R(context), U8(14),
+ /* 153 S> */ B(LdaZero),
+ /* 153 E> */ B(StaContextSlot), R(context), U8(15),
+ /* 165 S> */ B(LdaZero),
+ /* 165 E> */ B(StaContextSlot), R(context), U8(16),
+ /* 178 S> */ B(LdaZero),
+ /* 178 E> */ B(StaContextSlot), R(context), U8(17),
+ /* 191 S> */ B(LdaZero),
+ /* 191 E> */ B(StaContextSlot), R(context), U8(18),
+ /* 204 S> */ B(LdaZero),
+ /* 204 E> */ B(StaContextSlot), R(context), U8(19),
+ /* 217 S> */ B(LdaZero),
+ /* 217 E> */ B(StaContextSlot), R(context), U8(20),
+ /* 230 S> */ B(LdaZero),
+ /* 230 E> */ B(StaContextSlot), R(context), U8(21),
+ /* 243 S> */ B(LdaZero),
+ /* 243 E> */ B(StaContextSlot), R(context), U8(22),
+ /* 256 S> */ B(LdaZero),
+ /* 256 E> */ B(StaContextSlot), R(context), U8(23),
+ /* 269 S> */ B(LdaZero),
+ /* 269 E> */ B(StaContextSlot), R(context), U8(24),
+ /* 282 S> */ B(LdaZero),
+ /* 282 E> */ B(StaContextSlot), R(context), U8(25),
+ /* 295 S> */ B(LdaZero),
+ /* 295 E> */ B(StaContextSlot), R(context), U8(26),
+ /* 308 S> */ B(LdaZero),
+ /* 308 E> */ B(StaContextSlot), R(context), U8(27),
+ /* 321 S> */ B(LdaZero),
+ /* 321 E> */ B(StaContextSlot), R(context), U8(28),
+ /* 334 S> */ B(LdaZero),
+ /* 334 E> */ B(StaContextSlot), R(context), U8(29),
+ /* 347 S> */ B(LdaZero),
+ /* 347 E> */ B(StaContextSlot), R(context), U8(30),
+ /* 360 S> */ B(LdaZero),
+ /* 360 E> */ B(StaContextSlot), R(context), U8(31),
+ /* 373 S> */ B(LdaZero),
+ /* 373 E> */ B(StaContextSlot), R(context), U8(32),
+ /* 386 S> */ B(LdaZero),
+ /* 386 E> */ B(StaContextSlot), R(context), U8(33),
+ /* 399 S> */ B(LdaZero),
+ /* 399 E> */ B(StaContextSlot), R(context), U8(34),
+ /* 412 S> */ B(LdaZero),
+ /* 412 E> */ B(StaContextSlot), R(context), U8(35),
+ /* 425 S> */ B(LdaZero),
+ /* 425 E> */ B(StaContextSlot), R(context), U8(36),
+ /* 438 S> */ B(LdaZero),
+ /* 438 E> */ B(StaContextSlot), R(context), U8(37),
+ /* 451 S> */ B(LdaZero),
+ /* 451 E> */ B(StaContextSlot), R(context), U8(38),
+ /* 464 S> */ B(LdaZero),
+ /* 464 E> */ B(StaContextSlot), R(context), U8(39),
+ /* 477 S> */ B(LdaZero),
+ /* 477 E> */ B(StaContextSlot), R(context), U8(40),
+ /* 490 S> */ B(LdaZero),
+ /* 490 E> */ B(StaContextSlot), R(context), U8(41),
+ /* 503 S> */ B(LdaZero),
+ /* 503 E> */ B(StaContextSlot), R(context), U8(42),
+ /* 516 S> */ B(LdaZero),
+ /* 516 E> */ B(StaContextSlot), R(context), U8(43),
+ /* 529 S> */ B(LdaZero),
+ /* 529 E> */ B(StaContextSlot), R(context), U8(44),
+ /* 542 S> */ B(LdaZero),
+ /* 542 E> */ B(StaContextSlot), R(context), U8(45),
+ /* 555 S> */ B(LdaZero),
+ /* 555 E> */ B(StaContextSlot), R(context), U8(46),
+ /* 568 S> */ B(LdaZero),
+ /* 568 E> */ B(StaContextSlot), R(context), U8(47),
+ /* 581 S> */ B(LdaZero),
+ /* 581 E> */ B(StaContextSlot), R(context), U8(48),
+ /* 594 S> */ B(LdaZero),
+ /* 594 E> */ B(StaContextSlot), R(context), U8(49),
+ /* 607 S> */ B(LdaZero),
+ /* 607 E> */ B(StaContextSlot), R(context), U8(50),
+ /* 620 S> */ B(LdaZero),
+ /* 620 E> */ B(StaContextSlot), R(context), U8(51),
+ /* 633 S> */ B(LdaZero),
+ /* 633 E> */ B(StaContextSlot), R(context), U8(52),
+ /* 646 S> */ B(LdaZero),
+ /* 646 E> */ B(StaContextSlot), R(context), U8(53),
+ /* 659 S> */ B(LdaZero),
+ /* 659 E> */ B(StaContextSlot), R(context), U8(54),
+ /* 672 S> */ B(LdaZero),
+ /* 672 E> */ B(StaContextSlot), R(context), U8(55),
+ /* 685 S> */ B(LdaZero),
+ /* 685 E> */ B(StaContextSlot), R(context), U8(56),
+ /* 698 S> */ B(LdaZero),
+ /* 698 E> */ B(StaContextSlot), R(context), U8(57),
+ /* 711 S> */ B(LdaZero),
+ /* 711 E> */ B(StaContextSlot), R(context), U8(58),
+ /* 724 S> */ B(LdaZero),
+ /* 724 E> */ B(StaContextSlot), R(context), U8(59),
+ /* 737 S> */ B(LdaZero),
+ /* 737 E> */ B(StaContextSlot), R(context), U8(60),
+ /* 750 S> */ B(LdaZero),
+ /* 750 E> */ B(StaContextSlot), R(context), U8(61),
+ /* 763 S> */ B(LdaZero),
+ /* 763 E> */ B(StaContextSlot), R(context), U8(62),
+ /* 776 S> */ B(LdaZero),
+ /* 776 E> */ B(StaContextSlot), R(context), U8(63),
+ /* 789 S> */ B(LdaZero),
+ /* 789 E> */ B(StaContextSlot), R(context), U8(64),
+ /* 802 S> */ B(LdaZero),
+ /* 802 E> */ B(StaContextSlot), R(context), U8(65),
+ /* 815 S> */ B(LdaZero),
+ /* 815 E> */ B(StaContextSlot), R(context), U8(66),
+ /* 828 S> */ B(LdaZero),
+ /* 828 E> */ B(StaContextSlot), R(context), U8(67),
+ /* 841 S> */ B(LdaZero),
+ /* 841 E> */ B(StaContextSlot), R(context), U8(68),
+ /* 854 S> */ B(LdaZero),
+ /* 854 E> */ B(StaContextSlot), R(context), U8(69),
+ /* 867 S> */ B(LdaZero),
+ /* 867 E> */ B(StaContextSlot), R(context), U8(70),
+ /* 880 S> */ B(LdaZero),
+ /* 880 E> */ B(StaContextSlot), R(context), U8(71),
+ /* 893 S> */ B(LdaZero),
+ /* 893 E> */ B(StaContextSlot), R(context), U8(72),
+ /* 906 S> */ B(LdaZero),
+ /* 906 E> */ B(StaContextSlot), R(context), U8(73),
+ /* 919 S> */ B(LdaZero),
+ /* 919 E> */ B(StaContextSlot), R(context), U8(74),
+ /* 932 S> */ B(LdaZero),
+ /* 932 E> */ B(StaContextSlot), R(context), U8(75),
+ /* 945 S> */ B(LdaZero),
+ /* 945 E> */ B(StaContextSlot), R(context), U8(76),
+ /* 958 S> */ B(LdaZero),
+ /* 958 E> */ B(StaContextSlot), R(context), U8(77),
+ /* 971 S> */ B(LdaZero),
+ /* 971 E> */ B(StaContextSlot), R(context), U8(78),
+ /* 984 S> */ B(LdaZero),
+ /* 984 E> */ B(StaContextSlot), R(context), U8(79),
+ /* 997 S> */ B(LdaZero),
+ /* 997 E> */ B(StaContextSlot), R(context), U8(80),
+ /* 1010 S> */ B(LdaZero),
+ /* 1010 E> */ B(StaContextSlot), R(context), U8(81),
+ /* 1023 S> */ B(LdaZero),
+ /* 1023 E> */ B(StaContextSlot), R(context), U8(82),
+ /* 1036 S> */ B(LdaZero),
+ /* 1036 E> */ B(StaContextSlot), R(context), U8(83),
+ /* 1049 S> */ B(LdaZero),
+ /* 1049 E> */ B(StaContextSlot), R(context), U8(84),
+ /* 1062 S> */ B(LdaZero),
+ /* 1062 E> */ B(StaContextSlot), R(context), U8(85),
+ /* 1075 S> */ B(LdaZero),
+ /* 1075 E> */ B(StaContextSlot), R(context), U8(86),
+ /* 1088 S> */ B(LdaZero),
+ /* 1088 E> */ B(StaContextSlot), R(context), U8(87),
+ /* 1101 S> */ B(LdaZero),
+ /* 1101 E> */ B(StaContextSlot), R(context), U8(88),
+ /* 1114 S> */ B(LdaZero),
+ /* 1114 E> */ B(StaContextSlot), R(context), U8(89),
+ /* 1127 S> */ B(LdaZero),
+ /* 1127 E> */ B(StaContextSlot), R(context), U8(90),
+ /* 1140 S> */ B(LdaZero),
+ /* 1140 E> */ B(StaContextSlot), R(context), U8(91),
+ /* 1153 S> */ B(LdaZero),
+ /* 1153 E> */ B(StaContextSlot), R(context), U8(92),
+ /* 1166 S> */ B(LdaZero),
+ /* 1166 E> */ B(StaContextSlot), R(context), U8(93),
+ /* 1179 S> */ B(LdaZero),
+ /* 1179 E> */ B(StaContextSlot), R(context), U8(94),
+ /* 1192 S> */ B(LdaZero),
+ /* 1192 E> */ B(StaContextSlot), R(context), U8(95),
+ /* 1205 S> */ B(LdaZero),
+ /* 1205 E> */ B(StaContextSlot), R(context), U8(96),
+ /* 1218 S> */ B(LdaZero),
+ /* 1218 E> */ B(StaContextSlot), R(context), U8(97),
+ /* 1231 S> */ B(LdaZero),
+ /* 1231 E> */ B(StaContextSlot), R(context), U8(98),
+ /* 1244 S> */ B(LdaZero),
+ /* 1244 E> */ B(StaContextSlot), R(context), U8(99),
+ /* 1257 S> */ B(LdaZero),
+ /* 1257 E> */ B(StaContextSlot), R(context), U8(100),
+ /* 1270 S> */ B(LdaZero),
+ /* 1270 E> */ B(StaContextSlot), R(context), U8(101),
+ /* 1283 S> */ B(LdaZero),
+ /* 1283 E> */ B(StaContextSlot), R(context), U8(102),
+ /* 1296 S> */ B(LdaZero),
+ /* 1296 E> */ B(StaContextSlot), R(context), U8(103),
+ /* 1309 S> */ B(LdaZero),
+ /* 1309 E> */ B(StaContextSlot), R(context), U8(104),
+ /* 1322 S> */ B(LdaZero),
+ /* 1322 E> */ B(StaContextSlot), R(context), U8(105),
+ /* 1335 S> */ B(LdaZero),
+ /* 1335 E> */ B(StaContextSlot), R(context), U8(106),
+ /* 1349 S> */ B(LdaZero),
+ /* 1349 E> */ B(StaContextSlot), R(context), U8(107),
+ /* 1363 S> */ B(LdaZero),
+ /* 1363 E> */ B(StaContextSlot), R(context), U8(108),
+ /* 1377 S> */ B(LdaZero),
+ /* 1377 E> */ B(StaContextSlot), R(context), U8(109),
+ /* 1391 S> */ B(LdaZero),
+ /* 1391 E> */ B(StaContextSlot), R(context), U8(110),
+ /* 1405 S> */ B(LdaZero),
+ /* 1405 E> */ B(StaContextSlot), R(context), U8(111),
+ /* 1419 S> */ B(LdaZero),
+ /* 1419 E> */ B(StaContextSlot), R(context), U8(112),
+ /* 1433 S> */ B(LdaZero),
+ /* 1433 E> */ B(StaContextSlot), R(context), U8(113),
+ /* 1447 S> */ B(LdaZero),
+ /* 1447 E> */ B(StaContextSlot), R(context), U8(114),
+ /* 1461 S> */ B(LdaZero),
+ /* 1461 E> */ B(StaContextSlot), R(context), U8(115),
+ /* 1475 S> */ B(LdaZero),
+ /* 1475 E> */ B(StaContextSlot), R(context), U8(116),
+ /* 1489 S> */ B(LdaZero),
+ /* 1489 E> */ B(StaContextSlot), R(context), U8(117),
+ /* 1503 S> */ B(LdaZero),
+ /* 1503 E> */ B(StaContextSlot), R(context), U8(118),
+ /* 1517 S> */ B(LdaZero),
+ /* 1517 E> */ B(StaContextSlot), R(context), U8(119),
+ /* 1531 S> */ B(LdaZero),
+ /* 1531 E> */ B(StaContextSlot), R(context), U8(120),
+ /* 1545 S> */ B(LdaZero),
+ /* 1545 E> */ B(StaContextSlot), R(context), U8(121),
+ /* 1559 S> */ B(LdaZero),
+ /* 1559 E> */ B(StaContextSlot), R(context), U8(122),
+ /* 1573 S> */ B(LdaZero),
+ /* 1573 E> */ B(StaContextSlot), R(context), U8(123),
+ /* 1587 S> */ B(LdaZero),
+ /* 1587 E> */ B(StaContextSlot), R(context), U8(124),
+ /* 1601 S> */ B(LdaZero),
+ /* 1601 E> */ B(StaContextSlot), R(context), U8(125),
+ /* 1615 S> */ B(LdaZero),
+ /* 1615 E> */ B(StaContextSlot), R(context), U8(126),
+ /* 1629 S> */ B(LdaZero),
+ /* 1629 E> */ B(StaContextSlot), R(context), U8(127),
+ /* 1643 S> */ B(LdaZero),
+ /* 1643 E> */ B(StaContextSlot), R(context), U8(128),
+ /* 1657 S> */ B(LdaZero),
+ /* 1657 E> */ B(StaContextSlot), R(context), U8(129),
+ /* 1671 S> */ B(LdaZero),
+ /* 1671 E> */ B(StaContextSlot), R(context), U8(130),
+ /* 1685 S> */ B(LdaZero),
+ /* 1685 E> */ B(StaContextSlot), R(context), U8(131),
+ /* 1699 S> */ B(LdaZero),
+ /* 1699 E> */ B(StaContextSlot), R(context), U8(132),
+ /* 1713 S> */ B(LdaZero),
+ /* 1713 E> */ B(StaContextSlot), R(context), U8(133),
+ /* 1727 S> */ B(LdaZero),
+ /* 1727 E> */ B(StaContextSlot), R(context), U8(134),
+ /* 1741 S> */ B(LdaZero),
+ /* 1741 E> */ B(StaContextSlot), R(context), U8(135),
+ /* 1755 S> */ B(LdaZero),
+ /* 1755 E> */ B(StaContextSlot), R(context), U8(136),
+ /* 1769 S> */ B(LdaZero),
+ /* 1769 E> */ B(StaContextSlot), R(context), U8(137),
+ /* 1783 S> */ B(LdaZero),
+ /* 1783 E> */ B(StaContextSlot), R(context), U8(138),
+ /* 1797 S> */ B(LdaZero),
+ /* 1797 E> */ B(StaContextSlot), R(context), U8(139),
+ /* 1811 S> */ B(LdaZero),
+ /* 1811 E> */ B(StaContextSlot), R(context), U8(140),
+ /* 1825 S> */ B(LdaZero),
+ /* 1825 E> */ B(StaContextSlot), R(context), U8(141),
+ /* 1839 S> */ B(LdaZero),
+ /* 1839 E> */ B(StaContextSlot), R(context), U8(142),
+ /* 1853 S> */ B(LdaZero),
+ /* 1853 E> */ B(StaContextSlot), R(context), U8(143),
+ /* 1867 S> */ B(LdaZero),
+ /* 1867 E> */ B(StaContextSlot), R(context), U8(144),
+ /* 1881 S> */ B(LdaZero),
+ /* 1881 E> */ B(StaContextSlot), R(context), U8(145),
+ /* 1895 S> */ B(LdaZero),
+ /* 1895 E> */ B(StaContextSlot), R(context), U8(146),
+ /* 1909 S> */ B(LdaZero),
+ /* 1909 E> */ B(StaContextSlot), R(context), U8(147),
+ /* 1923 S> */ B(LdaZero),
+ /* 1923 E> */ B(StaContextSlot), R(context), U8(148),
+ /* 1937 S> */ B(LdaZero),
+ /* 1937 E> */ B(StaContextSlot), R(context), U8(149),
+ /* 1951 S> */ B(LdaZero),
+ /* 1951 E> */ B(StaContextSlot), R(context), U8(150),
+ /* 1965 S> */ B(LdaZero),
+ /* 1965 E> */ B(StaContextSlot), R(context), U8(151),
+ /* 1979 S> */ B(LdaZero),
+ /* 1979 E> */ B(StaContextSlot), R(context), U8(152),
+ /* 1993 S> */ B(LdaZero),
+ /* 1993 E> */ B(StaContextSlot), R(context), U8(153),
+ /* 2007 S> */ B(LdaZero),
+ /* 2007 E> */ B(StaContextSlot), R(context), U8(154),
+ /* 2021 S> */ B(LdaZero),
+ /* 2021 E> */ B(StaContextSlot), R(context), U8(155),
+ /* 2035 S> */ B(LdaZero),
+ /* 2035 E> */ B(StaContextSlot), R(context), U8(156),
+ /* 2049 S> */ B(LdaZero),
+ /* 2049 E> */ B(StaContextSlot), R(context), U8(157),
+ /* 2063 S> */ B(LdaZero),
+ /* 2063 E> */ B(StaContextSlot), R(context), U8(158),
+ /* 2077 S> */ B(LdaZero),
+ /* 2077 E> */ B(StaContextSlot), R(context), U8(159),
+ /* 2091 S> */ B(LdaZero),
+ /* 2091 E> */ B(StaContextSlot), R(context), U8(160),
+ /* 2105 S> */ B(LdaZero),
+ /* 2105 E> */ B(StaContextSlot), R(context), U8(161),
+ /* 2119 S> */ B(LdaZero),
+ /* 2119 E> */ B(StaContextSlot), R(context), U8(162),
+ /* 2133 S> */ B(LdaZero),
+ /* 2133 E> */ B(StaContextSlot), R(context), U8(163),
+ /* 2147 S> */ B(LdaZero),
+ /* 2147 E> */ B(StaContextSlot), R(context), U8(164),
+ /* 2161 S> */ B(LdaZero),
+ /* 2161 E> */ B(StaContextSlot), R(context), U8(165),
+ /* 2175 S> */ B(LdaZero),
+ /* 2175 E> */ B(StaContextSlot), R(context), U8(166),
+ /* 2189 S> */ B(LdaZero),
+ /* 2189 E> */ B(StaContextSlot), R(context), U8(167),
+ /* 2203 S> */ B(LdaZero),
+ /* 2203 E> */ B(StaContextSlot), R(context), U8(168),
+ /* 2217 S> */ B(LdaZero),
+ /* 2217 E> */ B(StaContextSlot), R(context), U8(169),
+ /* 2231 S> */ B(LdaZero),
+ /* 2231 E> */ B(StaContextSlot), R(context), U8(170),
+ /* 2245 S> */ B(LdaZero),
+ /* 2245 E> */ B(StaContextSlot), R(context), U8(171),
+ /* 2259 S> */ B(LdaZero),
+ /* 2259 E> */ B(StaContextSlot), R(context), U8(172),
+ /* 2273 S> */ B(LdaZero),
+ /* 2273 E> */ B(StaContextSlot), R(context), U8(173),
+ /* 2287 S> */ B(LdaZero),
+ /* 2287 E> */ B(StaContextSlot), R(context), U8(174),
+ /* 2301 S> */ B(LdaZero),
+ /* 2301 E> */ B(StaContextSlot), R(context), U8(175),
+ /* 2315 S> */ B(LdaZero),
+ /* 2315 E> */ B(StaContextSlot), R(context), U8(176),
+ /* 2329 S> */ B(LdaZero),
+ /* 2329 E> */ B(StaContextSlot), R(context), U8(177),
+ /* 2343 S> */ B(LdaZero),
+ /* 2343 E> */ B(StaContextSlot), R(context), U8(178),
+ /* 2357 S> */ B(LdaZero),
+ /* 2357 E> */ B(StaContextSlot), R(context), U8(179),
+ /* 2371 S> */ B(LdaZero),
+ /* 2371 E> */ B(StaContextSlot), R(context), U8(180),
+ /* 2385 S> */ B(LdaZero),
+ /* 2385 E> */ B(StaContextSlot), R(context), U8(181),
+ /* 2399 S> */ B(LdaZero),
+ /* 2399 E> */ B(StaContextSlot), R(context), U8(182),
+ /* 2413 S> */ B(LdaZero),
+ /* 2413 E> */ B(StaContextSlot), R(context), U8(183),
+ /* 2427 S> */ B(LdaZero),
+ /* 2427 E> */ B(StaContextSlot), R(context), U8(184),
+ /* 2441 S> */ B(LdaZero),
+ /* 2441 E> */ B(StaContextSlot), R(context), U8(185),
+ /* 2455 S> */ B(LdaZero),
+ /* 2455 E> */ B(StaContextSlot), R(context), U8(186),
+ /* 2469 S> */ B(LdaZero),
+ /* 2469 E> */ B(StaContextSlot), R(context), U8(187),
+ /* 2483 S> */ B(LdaZero),
+ /* 2483 E> */ B(StaContextSlot), R(context), U8(188),
+ /* 2497 S> */ B(LdaZero),
+ /* 2497 E> */ B(StaContextSlot), R(context), U8(189),
+ /* 2511 S> */ B(LdaZero),
+ /* 2511 E> */ B(StaContextSlot), R(context), U8(190),
+ /* 2525 S> */ B(LdaZero),
+ /* 2525 E> */ B(StaContextSlot), R(context), U8(191),
+ /* 2539 S> */ B(LdaZero),
+ /* 2539 E> */ B(StaContextSlot), R(context), U8(192),
+ /* 2553 S> */ B(LdaZero),
+ /* 2553 E> */ B(StaContextSlot), R(context), U8(193),
+ /* 2567 S> */ B(LdaZero),
+ /* 2567 E> */ B(StaContextSlot), R(context), U8(194),
+ /* 2581 S> */ B(LdaZero),
+ /* 2581 E> */ B(StaContextSlot), R(context), U8(195),
+ /* 2595 S> */ B(LdaZero),
+ /* 2595 E> */ B(StaContextSlot), R(context), U8(196),
+ /* 2609 S> */ B(LdaZero),
+ /* 2609 E> */ B(StaContextSlot), R(context), U8(197),
+ /* 2623 S> */ B(LdaZero),
+ /* 2623 E> */ B(StaContextSlot), R(context), U8(198),
+ /* 2637 S> */ B(LdaZero),
+ /* 2637 E> */ B(StaContextSlot), R(context), U8(199),
+ /* 2651 S> */ B(LdaZero),
+ /* 2651 E> */ B(StaContextSlot), R(context), U8(200),
+ /* 2665 S> */ B(LdaZero),
+ /* 2665 E> */ B(StaContextSlot), R(context), U8(201),
+ /* 2679 S> */ B(LdaZero),
+ /* 2679 E> */ B(StaContextSlot), R(context), U8(202),
+ /* 2693 S> */ B(LdaZero),
+ /* 2693 E> */ B(StaContextSlot), R(context), U8(203),
+ /* 2707 S> */ B(LdaZero),
+ /* 2707 E> */ B(StaContextSlot), R(context), U8(204),
+ /* 2721 S> */ B(LdaZero),
+ /* 2721 E> */ B(StaContextSlot), R(context), U8(205),
+ /* 2735 S> */ B(LdaZero),
+ /* 2735 E> */ B(StaContextSlot), R(context), U8(206),
+ /* 2749 S> */ B(LdaZero),
+ /* 2749 E> */ B(StaContextSlot), R(context), U8(207),
+ /* 2763 S> */ B(LdaZero),
+ /* 2763 E> */ B(StaContextSlot), R(context), U8(208),
+ /* 2777 S> */ B(LdaZero),
+ /* 2777 E> */ B(StaContextSlot), R(context), U8(209),
+ /* 2791 S> */ B(LdaZero),
+ /* 2791 E> */ B(StaContextSlot), R(context), U8(210),
+ /* 2805 S> */ B(LdaZero),
+ /* 2805 E> */ B(StaContextSlot), R(context), U8(211),
+ /* 2819 S> */ B(LdaZero),
+ /* 2819 E> */ B(StaContextSlot), R(context), U8(212),
+ /* 2833 S> */ B(LdaZero),
+ /* 2833 E> */ B(StaContextSlot), R(context), U8(213),
+ /* 2847 S> */ B(LdaZero),
+ /* 2847 E> */ B(StaContextSlot), R(context), U8(214),
+ /* 2861 S> */ B(LdaZero),
+ /* 2861 E> */ B(StaContextSlot), R(context), U8(215),
+ /* 2875 S> */ B(LdaZero),
+ /* 2875 E> */ B(StaContextSlot), R(context), U8(216),
+ /* 2889 S> */ B(LdaZero),
+ /* 2889 E> */ B(StaContextSlot), R(context), U8(217),
+ /* 2903 S> */ B(LdaZero),
+ /* 2903 E> */ B(StaContextSlot), R(context), U8(218),
+ /* 2917 S> */ B(LdaZero),
+ /* 2917 E> */ B(StaContextSlot), R(context), U8(219),
+ /* 2931 S> */ B(LdaZero),
+ /* 2931 E> */ B(StaContextSlot), R(context), U8(220),
+ /* 2945 S> */ B(LdaZero),
+ /* 2945 E> */ B(StaContextSlot), R(context), U8(221),
+ /* 2959 S> */ B(LdaZero),
+ /* 2959 E> */ B(StaContextSlot), R(context), U8(222),
+ /* 2973 S> */ B(LdaZero),
+ /* 2973 E> */ B(StaContextSlot), R(context), U8(223),
+ /* 2987 S> */ B(LdaZero),
+ /* 2987 E> */ B(StaContextSlot), R(context), U8(224),
+ /* 3001 S> */ B(LdaZero),
+ /* 3001 E> */ B(StaContextSlot), R(context), U8(225),
+ /* 3015 S> */ B(LdaZero),
+ /* 3015 E> */ B(StaContextSlot), R(context), U8(226),
+ /* 3029 S> */ B(LdaZero),
+ /* 3029 E> */ B(StaContextSlot), R(context), U8(227),
+ /* 3043 S> */ B(LdaZero),
+ /* 3043 E> */ B(StaContextSlot), R(context), U8(228),
+ /* 3057 S> */ B(LdaZero),
+ /* 3057 E> */ B(StaContextSlot), R(context), U8(229),
+ /* 3071 S> */ B(LdaZero),
+ /* 3071 E> */ B(StaContextSlot), R(context), U8(230),
+ /* 3085 S> */ B(LdaZero),
+ /* 3085 E> */ B(StaContextSlot), R(context), U8(231),
+ /* 3099 S> */ B(LdaZero),
+ /* 3099 E> */ B(StaContextSlot), R(context), U8(232),
+ /* 3113 S> */ B(LdaZero),
+ /* 3113 E> */ B(StaContextSlot), R(context), U8(233),
+ /* 3127 S> */ B(LdaZero),
+ /* 3127 E> */ B(StaContextSlot), R(context), U8(234),
+ /* 3141 S> */ B(LdaZero),
+ /* 3141 E> */ B(StaContextSlot), R(context), U8(235),
+ /* 3155 S> */ B(LdaZero),
+ /* 3155 E> */ B(StaContextSlot), R(context), U8(236),
+ /* 3169 S> */ B(LdaZero),
+ /* 3169 E> */ B(StaContextSlot), R(context), U8(237),
+ /* 3183 S> */ B(LdaZero),
+ /* 3183 E> */ B(StaContextSlot), R(context), U8(238),
+ /* 3197 S> */ B(LdaZero),
+ /* 3197 E> */ B(StaContextSlot), R(context), U8(239),
+ /* 3211 S> */ B(LdaZero),
+ /* 3211 E> */ B(StaContextSlot), R(context), U8(240),
+ /* 3225 S> */ B(LdaZero),
+ /* 3225 E> */ B(StaContextSlot), R(context), U8(241),
+ /* 3239 S> */ B(LdaZero),
+ /* 3239 E> */ B(StaContextSlot), R(context), U8(242),
+ /* 3253 S> */ B(LdaZero),
+ /* 3253 E> */ B(StaContextSlot), R(context), U8(243),
+ /* 3267 S> */ B(LdaZero),
+ /* 3267 E> */ B(StaContextSlot), R(context), U8(244),
+ /* 3281 S> */ B(LdaZero),
+ /* 3281 E> */ B(StaContextSlot), R(context), U8(245),
+ /* 3295 S> */ B(LdaZero),
+ /* 3295 E> */ B(StaContextSlot), R(context), U8(246),
+ /* 3309 S> */ B(LdaZero),
+ /* 3309 E> */ B(StaContextSlot), R(context), U8(247),
+ /* 3323 S> */ B(LdaZero),
+ /* 3323 E> */ B(StaContextSlot), R(context), U8(248),
+ /* 3337 S> */ B(LdaZero),
+ /* 3337 E> */ B(StaContextSlot), R(context), U8(249),
+ /* 3351 S> */ B(LdaZero),
+ /* 3351 E> */ B(StaContextSlot), R(context), U8(250),
+ /* 3365 S> */ B(LdaZero),
+ /* 3365 E> */ B(StaContextSlot), R(context), U8(251),
+ /* 3379 S> */ B(LdaZero),
+ /* 3379 E> */ B(StaContextSlot), R(context), U8(252),
+ /* 3393 S> */ B(LdaZero),
+ /* 3393 E> */ B(StaContextSlot), R(context), U8(253),
+ /* 3407 S> */ B(LdaZero),
+ /* 3407 E> */ B(StaContextSlot), R(context), U8(254),
+ /* 3421 S> */ B(LdaZero),
+ /* 3421 E> */ B(StaContextSlot), R(context), U8(255),
+ /* 3424 S> */ B(LdaUndefined),
+ B(Star), R(2),
+ /* 3424 E> */ B(LdaGlobal), U8(0), U8(1),
+ B(Star), R(1),
+ /* 3424 E> */ B(Call), R(1), R(2), U8(1), U8(0),
+ /* 3440 S> */ B(LdaSmi), U8(100),
+ /* 3440 E> */ B(Wide), B(StaContextSlot), R16(context), U16(256),
+ /* 3445 S> */ B(Wide), B(LdaContextSlot), R16(context), U16(256),
+ /* 3454 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/CountOperators.golden b/test/cctest/interpreter/bytecode_expectations/CountOperators.golden
index 8857789..db9dcf3 100644
--- a/test/cctest/interpreter/bytecode_expectations/CountOperators.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CountOperators.golden
@@ -13,15 +13,14 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 10
+bytecode array length: 9
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(ToNumber),
- B(Inc),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Inc),
+ /* 54 E> */ B(Star), R(0),
+ /* 57 S> */ B(Return),
]
constant pool: [
]
@@ -36,15 +35,15 @@
parameter count: 1
bytecode array length: 14
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(ToNumber),
- B(Star), R(1),
- B(Inc),
- B(Star), R(0),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(ToNumber),
+ B(Star), R(1),
+ B(Inc),
+ /* 53 E> */ B(Star), R(0),
+ B(Ldar), R(1),
+ /* 57 S> */ B(Return),
]
constant pool: [
]
@@ -57,15 +56,14 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 10
+bytecode array length: 9
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(ToNumber),
- B(Dec),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Dec),
+ /* 54 E> */ B(Star), R(0),
+ /* 57 S> */ B(Return),
]
constant pool: [
]
@@ -80,15 +78,15 @@
parameter count: 1
bytecode array length: 14
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(ToNumber),
- B(Star), R(1),
- B(Dec),
- B(Star), R(0),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(ToNumber),
+ B(Star), R(1),
+ B(Dec),
+ /* 53 E> */ B(Star), R(0),
+ B(Ldar), R(1),
+ /* 57 S> */ B(Return),
]
constant pool: [
]
@@ -103,18 +101,18 @@
parameter count: 1
bytecode array length: 26
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(1), U8(1),
- B(ToNumber),
- B(Star), R(2),
- B(Inc),
- B(StoreICSloppy), R(1), U8(1), U8(3),
- B(Ldar), R(2),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 54 S> */ B(Star), R(1),
+ B(LoadIC), R(1), U8(1), U8(1),
+ B(ToNumber),
+ B(Star), R(2),
+ B(Inc),
+ /* 66 E> */ B(StoreICSloppy), R(1), U8(1), U8(3),
+ B(Ldar), R(2),
+ /* 70 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -129,18 +127,17 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 22
+bytecode array length: 21
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(1), U8(1),
- B(ToNumber),
- B(Dec),
- B(StoreICSloppy), R(1), U8(1), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 54 S> */ B(Star), R(1),
+ B(LoadIC), R(1), U8(1), U8(1),
+ B(Dec),
+ /* 65 E> */ B(StoreICSloppy), R(1), U8(1), U8(3),
+ /* 70 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -157,22 +154,22 @@
parameter count: 1
bytecode array length: 33
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(CreateObjectLiteral), U8(1), U8(0), U8(5),
- B(Star), R(2),
- B(Star), R(1),
- B(Star), R(2),
- B(Ldar), R(0),
- B(Star), R(3),
- B(KeyedLoadIC), R(2), U8(1),
- B(ToNumber),
- B(Star), R(4),
- B(Dec),
- B(KeyedStoreICSloppy), R(2), R(3), U8(3),
- B(Ldar), R(4),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 45 S> */ B(LdaConstant), U8(0),
+ /* 45 E> */ B(Star), R(0),
+ /* 60 S> */ B(CreateObjectLiteral), U8(1), U8(0), U8(1),
+ B(Star), R(2),
+ /* 60 E> */ B(Star), R(1),
+ /* 72 S> */ B(Star), R(2),
+ /* 81 E> */ B(Ldar), R(0),
+ B(Star), R(3),
+ B(KeyedLoadIC), R(2), U8(1),
+ B(ToNumber),
+ B(Star), R(4),
+ B(Dec),
+ /* 86 E> */ B(KeyedStoreICSloppy), R(2), R(3), U8(3),
+ B(Ldar), R(4),
+ /* 90 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -187,22 +184,21 @@
"
frame size: 4
parameter count: 1
-bytecode array length: 29
+bytecode array length: 28
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(CreateObjectLiteral), U8(1), U8(0), U8(5),
- B(Star), R(2),
- B(Star), R(1),
- B(Star), R(2),
- B(Ldar), R(0),
- B(Star), R(3),
- B(KeyedLoadIC), R(2), U8(1),
- B(ToNumber),
- B(Inc),
- B(KeyedStoreICSloppy), R(2), R(3), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 45 S> */ B(LdaConstant), U8(0),
+ /* 45 E> */ B(Star), R(0),
+ /* 60 S> */ B(CreateObjectLiteral), U8(1), U8(0), U8(1),
+ B(Star), R(2),
+ /* 60 E> */ B(Star), R(1),
+ /* 72 S> */ B(Star), R(2),
+ /* 83 E> */ B(Ldar), R(0),
+ B(Star), R(3),
+ B(KeyedLoadIC), R(2), U8(1),
+ B(Inc),
+ /* 87 E> */ B(KeyedStoreICSloppy), R(2), R(3), U8(3),
+ /* 90 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -217,20 +213,19 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 27
+bytecode array length: 26
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(LdaContextSlot), R(context), U8(4),
- B(ToNumber),
- B(Inc),
- B(StaContextSlot), R(context), U8(4),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 53 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 53 E> */ B(Star), R(0),
+ /* 78 S> */ B(LdaContextSlot), R(context), U8(4),
+ B(Inc),
+ /* 87 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 90 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -246,20 +241,20 @@
parameter count: 1
bytecode array length: 31
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(LdaContextSlot), R(context), U8(4),
- B(ToNumber),
- B(Star), R(2),
- B(Dec),
- B(StaContextSlot), R(context), U8(4),
- B(Ldar), R(2),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 53 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 53 E> */ B(Star), R(0),
+ /* 78 S> */ B(LdaContextSlot), R(context), U8(4),
+ B(ToNumber),
+ B(Star), R(2),
+ B(Dec),
+ /* 86 E> */ B(StaContextSlot), R(context), U8(4),
+ B(Ldar), R(2),
+ /* 90 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -275,20 +270,20 @@
parameter count: 1
bytecode array length: 28
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(CreateArrayLiteral), U8(0), U8(0), U8(3),
- B(Star), R(1),
- B(Star), R(2),
- B(Ldar), R(0),
- B(ToNumber),
- B(Star), R(3),
- B(Inc),
- B(Star), R(0),
- B(LdaSmi), U8(2),
- B(KeyedStoreICSloppy), R(2), R(3), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 44 S> */ B(LdaSmi), U8(1),
+ /* 44 E> */ B(Star), R(0),
+ /* 55 S> */ B(CreateArrayLiteral), U8(0), U8(0), U8(3),
+ /* 55 E> */ B(Star), R(1),
+ /* 63 S> */ B(Star), R(2),
+ B(Ldar), R(0),
+ B(ToNumber),
+ B(Star), R(3),
+ B(Inc),
+ /* 75 E> */ B(Star), R(0),
+ B(LdaSmi), U8(2),
+ /* 79 E> */ B(KeyedStoreICSloppy), R(2), R(3), U8(1),
+ /* 84 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/CreateArguments.golden b/test/cctest/interpreter/bytecode_expectations/CreateArguments.golden
index ab60ba4..6788a7c 100644
--- a/test/cctest/interpreter/bytecode_expectations/CreateArguments.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CreateArguments.golden
@@ -17,11 +17,11 @@
parameter count: 1
bytecode array length: 7
bytecodes: [
- B(CreateMappedArguments),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Return),
+ B(CreateMappedArguments),
+ B(Star), R(0),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(Ldar), R(0),
+ /* 33 S> */ B(Return),
]
constant pool: [
]
@@ -37,14 +37,14 @@
parameter count: 1
bytecode array length: 13
bytecodes: [
- B(CreateMappedArguments),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaZero),
- B(KeyedLoadIC), R(1), U8(1),
- B(Return),
+ B(CreateMappedArguments),
+ B(Star), R(0),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ /* 31 E> */ B(LdaZero),
+ B(KeyedLoadIC), R(1), U8(1),
+ /* 36 S> */ B(Return),
]
constant pool: [
]
@@ -60,11 +60,11 @@
parameter count: 1
bytecode array length: 7
bytecodes: [
- B(CreateUnmappedArguments),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Return),
+ B(CreateUnmappedArguments),
+ B(Star), R(0),
+ /* 10 E> */ B(StackCheck),
+ /* 29 S> */ B(Ldar), R(0),
+ /* 47 S> */ B(Return),
]
constant pool: [
]
@@ -80,18 +80,18 @@
parameter count: 2
bytecode array length: 25
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(Ldar), R(arg0),
- B(StaContextSlot), R(context), U8(4),
- B(CreateMappedArguments),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaZero),
- B(KeyedLoadIC), R(2), U8(1),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(Ldar), R(arg0),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateMappedArguments),
+ B(Star), R(0),
+ /* 10 E> */ B(StackCheck),
+ /* 16 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ /* 32 E> */ B(LdaZero),
+ B(KeyedLoadIC), R(2), U8(1),
+ /* 37 S> */ B(Return),
]
constant pool: [
]
@@ -107,19 +107,19 @@
parameter count: 4
bytecode array length: 29
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(Ldar), R(arg0),
- B(StaContextSlot), R(context), U8(6),
- B(Ldar), R(arg1),
- B(StaContextSlot), R(context), U8(5),
- B(Ldar), R(arg2),
- B(StaContextSlot), R(context), U8(4),
- B(CreateMappedArguments),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(Ldar), R(arg0),
+ B(StaContextSlot), R(context), U8(6),
+ B(Ldar), R(arg1),
+ B(StaContextSlot), R(context), U8(5),
+ B(Ldar), R(arg2),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateMappedArguments),
+ B(Star), R(0),
+ /* 10 E> */ B(StackCheck),
+ /* 22 S> */ B(Ldar), R(0),
+ /* 40 S> */ B(Return),
]
constant pool: [
]
@@ -135,11 +135,11 @@
parameter count: 4
bytecode array length: 7
bytecodes: [
- B(CreateUnmappedArguments),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Return),
+ B(CreateUnmappedArguments),
+ B(Star), R(0),
+ /* 10 E> */ B(StackCheck),
+ /* 36 S> */ B(Ldar), R(0),
+ /* 54 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/CreateRestParameter.golden b/test/cctest/interpreter/bytecode_expectations/CreateRestParameter.golden
index e43a8cd..341ad9c 100644
--- a/test/cctest/interpreter/bytecode_expectations/CreateRestParameter.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CreateRestParameter.golden
@@ -17,11 +17,11 @@
parameter count: 1
bytecode array length: 7
bytecodes: [
- B(CreateRestParameter),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Return),
+ B(CreateRestParameter),
+ B(Star), R(0),
+ /* 10 E> */ B(StackCheck),
+ /* 26 S> */ B(Ldar), R(0),
+ /* 43 S> */ B(Return),
]
constant pool: [
]
@@ -37,15 +37,15 @@
parameter count: 2
bytecode array length: 14
bytecodes: [
- B(CreateRestParameter),
- B(Star), R(0),
- B(LdaTheHole),
- B(Star), R(1),
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Return),
+ B(CreateRestParameter),
+ B(Star), R(0),
+ B(LdaTheHole),
+ B(Star), R(1),
+ /* 10 E> */ B(StackCheck),
+ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 29 S> */ B(Ldar), R(0),
+ /* 46 S> */ B(Return),
]
constant pool: [
]
@@ -61,18 +61,18 @@
parameter count: 2
bytecode array length: 20
bytecodes: [
- B(CreateRestParameter),
- B(Star), R(0),
- B(LdaTheHole),
- B(Star), R(1),
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaZero),
- B(KeyedLoadIC), R(2), U8(1),
- B(Return),
+ B(CreateRestParameter),
+ B(Star), R(0),
+ B(LdaTheHole),
+ B(Star), R(1),
+ /* 10 E> */ B(StackCheck),
+ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 29 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ /* 44 E> */ B(LdaZero),
+ B(KeyedLoadIC), R(2), U8(1),
+ /* 49 S> */ B(Return),
]
constant pool: [
]
@@ -88,26 +88,26 @@
parameter count: 2
bytecode array length: 35
bytecodes: [
- B(CreateUnmappedArguments),
- B(Star), R(0),
- B(CreateRestParameter),
- B(Star), R(1),
- B(LdaTheHole),
- B(Star), R(2),
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(2),
- B(Ldar), R(1),
- B(Star), R(3),
- B(LdaZero),
- B(KeyedLoadIC), R(3), U8(1),
- B(Star), R(4),
- B(Ldar), R(0),
- B(Star), R(3),
- B(LdaZero),
- B(KeyedLoadIC), R(3), U8(3),
- B(Add), R(4),
- B(Return),
+ B(CreateUnmappedArguments),
+ B(Star), R(0),
+ B(CreateRestParameter),
+ B(Star), R(1),
+ B(LdaTheHole),
+ B(Star), R(2),
+ /* 10 E> */ B(StackCheck),
+ B(Ldar), R(arg0),
+ B(Star), R(2),
+ /* 29 S> */ B(Ldar), R(1),
+ B(Star), R(3),
+ /* 44 E> */ B(LdaZero),
+ B(KeyedLoadIC), R(3), U8(1),
+ B(Star), R(4),
+ /* 50 E> */ B(Ldar), R(0),
+ B(Star), R(3),
+ /* 59 E> */ B(LdaZero),
+ B(KeyedLoadIC), R(3), U8(3),
+ B(Add), R(4),
+ /* 64 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/DeadCodeRemoval.golden b/test/cctest/interpreter/bytecode_expectations/DeadCodeRemoval.golden
index 0c7c176..29f101a 100644
--- a/test/cctest/interpreter/bytecode_expectations/DeadCodeRemoval.golden
+++ b/test/cctest/interpreter/bytecode_expectations/DeadCodeRemoval.golden
@@ -15,9 +15,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaUndefined),
+ /* 58 S> */ B(Return),
]
constant pool: [
]
@@ -32,11 +32,11 @@
parameter count: 1
bytecode array length: 7
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 66 S> */ B(LdaSmi), U8(1),
+ /* 66 E> */ B(Star), R(0),
+ B(LdaUndefined),
+ /* 69 S> */ B(Return),
]
constant pool: [
]
@@ -51,9 +51,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 46 S> */ B(LdaSmi), U8(1),
+ /* 78 S> */ B(Return),
]
constant pool: [
]
@@ -68,14 +68,14 @@
parameter count: 1
bytecode array length: 13
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(JumpIfToBooleanFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(LdaSmi), U8(2),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanFalse), U8(5),
+ /* 54 S> */ B(LdaSmi), U8(1),
+ /* 77 S> */ B(Return),
+ /* 67 S> */ B(LdaSmi), U8(2),
+ /* 77 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/DeclareGlobals.golden b/test/cctest/interpreter/bytecode_expectations/DeclareGlobals.golden
index bedbe31..a1505f0 100644
--- a/test/cctest/interpreter/bytecode_expectations/DeclareGlobals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/DeclareGlobals.golden
@@ -16,21 +16,21 @@
parameter count: 1
bytecode array length: 31
bytecodes: [
- B(LdaConstant), U8(0),
- B(Star), R(1),
- B(LdaZero),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kDeclareGlobals), R(1), U8(2),
- B(StackCheck),
- B(LdaConstant), U8(1),
- B(Star), R(1),
- B(LdaZero),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kInitializeVarGlobal), R(1), U8(3),
- B(LdaUndefined),
- B(Return),
+ B(LdaConstant), U8(0),
+ B(Star), R(1),
+ B(LdaZero),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kDeclareGlobals), R(1), U8(2),
+ /* 0 E> */ B(StackCheck),
+ /* 8 S> */ B(LdaConstant), U8(1),
+ B(Star), R(1),
+ B(LdaZero),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kInitializeVarGlobal), R(1), U8(3),
+ B(LdaUndefined),
+ /* 10 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -47,14 +47,14 @@
parameter count: 1
bytecode array length: 15
bytecodes: [
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaZero),
- B(Star), R(1),
- B(CallRuntime), U16(Runtime::kDeclareGlobals), R(0), U8(2),
- B(StackCheck),
- B(LdaUndefined),
- B(Return),
+ B(LdaConstant), U8(0),
+ B(Star), R(0),
+ B(LdaZero),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kDeclareGlobals), R(0), U8(2),
+ /* 0 E> */ B(StackCheck),
+ B(LdaUndefined),
+ /* 15 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -71,23 +71,23 @@
parameter count: 1
bytecode array length: 37
bytecodes: [
- B(LdaConstant), U8(0),
- B(Star), R(1),
- B(LdaZero),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kDeclareGlobals), R(1), U8(2),
- B(StackCheck),
- B(LdaConstant), U8(1),
- B(Star), R(1),
- B(LdaZero),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kInitializeVarGlobal), R(1), U8(3),
- B(LdaSmi), U8(2),
- B(StaGlobalSloppy), U8(1), U8(3),
- B(Star), R(0),
- B(Return),
+ B(LdaConstant), U8(0),
+ B(Star), R(1),
+ B(LdaZero),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kDeclareGlobals), R(1), U8(2),
+ /* 0 E> */ B(StackCheck),
+ /* 8 S> */ B(LdaConstant), U8(1),
+ B(Star), R(1),
+ B(LdaZero),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kInitializeVarGlobal), R(1), U8(3),
+ /* 11 S> */ B(LdaSmi), U8(2),
+ /* 12 E> */ B(StaGlobalSloppy), U8(1), U8(3),
+ B(Star), R(0),
+ /* 15 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -105,19 +105,19 @@
parameter count: 1
bytecode array length: 29
bytecodes: [
- B(LdaConstant), U8(0),
- B(Star), R(1),
- B(LdaZero),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kDeclareGlobals), R(1), U8(2),
- B(StackCheck),
- B(LdaUndefined),
- B(Star), R(2),
- B(LdaGlobal), U8(1), U8(1),
- B(Star), R(1),
- B(Call), R(1), R(2), U8(1), U8(3),
- B(Star), R(0),
- B(Return),
+ B(LdaConstant), U8(0),
+ B(Star), R(1),
+ B(LdaZero),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kDeclareGlobals), R(1), U8(2),
+ /* 0 E> */ B(StackCheck),
+ /* 16 S> */ B(LdaUndefined),
+ B(Star), R(2),
+ B(LdaGlobal), U8(1), U8(1),
+ B(Star), R(1),
+ /* 16 E> */ B(Call), R(1), R(2), U8(1), U8(3),
+ B(Star), R(0),
+ /* 20 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/Delete.golden b/test/cctest/interpreter/bytecode_expectations/Delete.golden
index 369c158..2a355ab 100644
--- a/test/cctest/interpreter/bytecode_expectations/Delete.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Delete.golden
@@ -15,14 +15,14 @@
parameter count: 1
bytecode array length: 16
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaConstant), U8(1),
- B(DeletePropertySloppy), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 56 S> */ B(Star), R(1),
+ B(LdaConstant), U8(1),
+ B(DeletePropertySloppy), R(1),
+ /* 75 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -39,14 +39,14 @@
parameter count: 1
bytecode array length: 16
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaConstant), U8(1),
- B(DeletePropertyStrict), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 56 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 56 E> */ B(Star), R(0),
+ /* 70 S> */ B(Star), R(1),
+ B(LdaConstant), U8(1),
+ B(DeletePropertyStrict), R(1),
+ /* 89 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -63,14 +63,14 @@
parameter count: 1
bytecode array length: 16
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(DeletePropertySloppy), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 56 S> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ B(DeletePropertySloppy), R(1),
+ /* 76 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -86,11 +86,11 @@
parameter count: 1
bytecode array length: 7
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(LdaFalse),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(LdaFalse),
+ /* 63 S> */ B(Return),
]
constant pool: [
]
@@ -108,18 +108,18 @@
parameter count: 1
bytecode array length: 30
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(1), U8(0),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(DeletePropertyStrict), R(1),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 56 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 56 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 64 S> */ B(CreateClosure), U8(1), U8(0),
+ /* 93 S> */ B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(DeletePropertyStrict), R(1),
+ /* 113 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -136,9 +136,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaTrue),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaTrue),
+ /* 56 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/DeleteLookupSlotInEval.golden b/test/cctest/interpreter/bytecode_expectations/DeleteLookupSlotInEval.golden
index b36f421..dcc7213 100644
--- a/test/cctest/interpreter/bytecode_expectations/DeleteLookupSlotInEval.golden
+++ b/test/cctest/interpreter/bytecode_expectations/DeleteLookupSlotInEval.golden
@@ -23,12 +23,12 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(CallRuntime), U16(Runtime::kDeleteLookupSlot), R(0), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(LdaConstant), U8(0),
+ B(Star), R(0),
+ B(CallRuntime), U16(Runtime::kDeleteLookupSlot), R(0), U8(1),
+ B(LdaUndefined),
+ /* 25 S> */ B(Return),
]
constant pool: [
"x",
@@ -51,9 +51,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaFalse),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(LdaFalse),
+ /* 32 S> */ B(Return),
]
constant pool: [
]
@@ -75,11 +75,11 @@
parameter count: 1
bytecode array length: 11
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(CallRuntime), U16(Runtime::kDeleteLookupSlot), R(0), U8(1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(LdaConstant), U8(0),
+ B(Star), R(0),
+ B(CallRuntime), U16(Runtime::kDeleteLookupSlot), R(0), U8(1),
+ /* 32 S> */ B(Return),
]
constant pool: [
"z",
diff --git a/test/cctest/interpreter/bytecode_expectations/DoDebugger.golden b/test/cctest/interpreter/bytecode_expectations/DoDebugger.golden
index ca26065..ac0b2ee 100644
--- a/test/cctest/interpreter/bytecode_expectations/DoDebugger.golden
+++ b/test/cctest/interpreter/bytecode_expectations/DoDebugger.golden
@@ -15,10 +15,10 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(Debugger),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(Debugger),
+ B(LdaUndefined),
+ /* 44 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/DoExpression.golden b/test/cctest/interpreter/bytecode_expectations/DoExpression.golden
index b46fa57..68f264f 100644
--- a/test/cctest/interpreter/bytecode_expectations/DoExpression.golden
+++ b/test/cctest/interpreter/bytecode_expectations/DoExpression.golden
@@ -16,10 +16,10 @@
parameter count: 1
bytecode array length: 6
bytecodes: [
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(Ldar), R(0),
+ /* 42 E> */ B(Star), R(1),
+ /* 60 S> */ B(Return),
]
constant pool: [
]
@@ -34,13 +34,13 @@
parameter count: 1
bytecode array length: 11
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(100),
- B(Star), R(1),
- B(LdaUndefined),
- B(Star), R(0),
- B(Star), R(2),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 55 S> */ B(LdaSmi), U8(100),
+ /* 55 E> */ B(Star), R(1),
+ /* 42 S> */ B(LdaUndefined),
+ B(Star), R(0),
+ /* 42 E> */ B(Star), R(2),
+ /* 73 S> */ B(Return),
]
constant pool: [
]
@@ -53,24 +53,23 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 26
+bytecode array length: 25
bytecodes: [
- B(StackCheck),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(1),
- B(ToNumber),
- B(Inc),
- B(Star), R(1),
- B(Star), R(0),
- B(Jump), U8(12),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(20),
- B(Star), R(1),
- B(Jump), U8(-21),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 E> */ B(StackCheck),
+ /* 56 S> */ B(LdaSmi), U8(10),
+ /* 56 E> */ B(Star), R(1),
+ /* 69 S> */ B(Inc),
+ /* 71 E> */ B(Star), R(1),
+ B(Star), R(0),
+ /* 74 S> */ B(Jump), U8(12),
+ /* 64 E> */ B(Ldar), R(0),
+ /* 62 E> */ B(Star), R(1),
+ /* 84 S> */ B(LdaSmi), U8(20),
+ /* 86 E> */ B(Star), R(1),
+ B(Jump), U8(-20),
+ B(LdaUndefined),
+ /* 94 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/Eval.golden b/test/cctest/interpreter/bytecode_expectations/Eval.golden
index e3e48bc..7c3915c 100644
--- a/test/cctest/interpreter/bytecode_expectations/Eval.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Eval.golden
@@ -11,35 +11,37 @@
snippet: "
return eval('1;');
"
-frame size: 9
+frame size: 10
parameter count: 1
-bytecode array length: 65
+bytecode array length: 69
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(Ldar), R(this),
- B(StaContextSlot), R(context), U8(4),
- B(CreateMappedArguments),
- B(StaContextSlot), R(context), U8(5),
- B(Ldar), R(new_target),
- B(StaContextSlot), R(context), U8(6),
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(3),
- B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(Mov), R(1), R(4),
- B(Mov), R(3), R(5),
- B(Mov), R(closure), R(6),
- B(LdaZero),
- B(Star), R(7),
- B(LdaSmi), U8(30),
- B(Star), R(8),
- B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), U8(5),
- B(Star), R(1),
- B(Call), R(1), R(2), U8(2), U8(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(this),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateMappedArguments),
+ B(StaContextSlot), R(context), U8(5),
+ B(Ldar), R(new_target),
+ B(StaContextSlot), R(context), U8(6),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaConstant), U8(0),
+ B(Star), R(3),
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
+ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(Mov), R(1), R(4),
+ B(Mov), R(3), R(5),
+ B(Mov), R(closure), R(6),
+ B(LdaZero),
+ B(Star), R(7),
+ B(LdaSmi), U8(30),
+ B(Star), R(8),
+ B(LdaSmi), U8(41),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), U8(6),
+ B(Star), R(1),
+ /* 41 E> */ B(Call), R(1), R(2), U8(2), U8(0),
+ /* 53 S> */ B(Return),
]
constant pool: [
"eval",
diff --git a/test/cctest/interpreter/bytecode_expectations/ForIn.golden b/test/cctest/interpreter/bytecode_expectations/ForIn.golden
index 9f0c64a..2b61b64 100644
--- a/test/cctest/interpreter/bytecode_expectations/ForIn.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ForIn.golden
@@ -15,9 +15,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ B(LdaUndefined),
+ /* 57 S> */ B(Return),
]
constant pool: [
]
@@ -32,9 +32,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ B(LdaUndefined),
+ /* 62 S> */ B(Return),
]
constant pool: [
]
@@ -49,9 +49,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ B(LdaUndefined),
+ /* 62 S> */ B(Return),
]
constant pool: [
]
@@ -67,30 +67,30 @@
parameter count: 1
bytecode array length: 45
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(1),
- B(JumpIfUndefined), U8(38),
- B(JumpIfNull), U8(36),
- B(ToObject),
- B(Star), R(3),
- B(ForInPrepare), R(4),
- B(LdaZero),
- B(Star), R(7),
- B(ForInDone), R(7), R(6),
- B(JumpIfTrue), U8(23),
- B(ForInNext), R(3), R(7), R(4), U8(1),
- B(JumpIfUndefined), U8(10),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(2),
- B(Return),
- B(ForInStep), R(7),
- B(Star), R(7),
- B(Jump), U8(-24),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(1),
+ /* 68 S> */ B(JumpIfUndefined), U8(38),
+ B(JumpIfNull), U8(36),
+ B(ToObject),
+ B(Star), R(3),
+ B(ForInPrepare), R(4),
+ B(LdaZero),
+ B(Star), R(7),
+ /* 63 S> */ B(ForInDone), R(7), R(6),
+ B(JumpIfTrue), U8(23),
+ B(ForInNext), R(3), R(7), R(4), U8(1),
+ B(JumpIfUndefined), U8(10),
+ B(Star), R(0),
+ /* 54 E> */ B(StackCheck),
+ B(Ldar), R(0),
+ B(Star), R(2),
+ /* 85 S> */ B(Return),
+ B(ForInStep), R(7),
+ B(Star), R(7),
+ B(Jump), U8(-24),
+ B(LdaUndefined),
+ /* 85 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -107,35 +107,35 @@
parameter count: 1
bytecode array length: 57
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(1),
- B(CreateArrayLiteral), U8(0), U8(0), U8(3),
- B(JumpIfUndefined), U8(47),
- B(JumpIfNull), U8(45),
- B(ToObject),
- B(Star), R(3),
- B(ForInPrepare), R(4),
- B(LdaZero),
- B(Star), R(7),
- B(ForInDone), R(7), R(6),
- B(JumpIfTrue), U8(32),
- B(ForInNext), R(3), R(7), R(4), U8(1),
- B(JumpIfUndefined), U8(19),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(2),
- B(Ldar), R(1),
- B(Star), R(8),
- B(Ldar), R(2),
- B(Add), R(8),
- B(Star), R(1),
- B(ForInStep), R(7),
- B(Star), R(7),
- B(Jump), U8(-33),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(1),
+ /* 59 S> */ B(CreateArrayLiteral), U8(0), U8(0), U8(3),
+ B(JumpIfUndefined), U8(47),
+ B(JumpIfNull), U8(45),
+ B(ToObject),
+ B(Star), R(3),
+ B(ForInPrepare), R(4),
+ B(LdaZero),
+ B(Star), R(7),
+ /* 54 S> */ B(ForInDone), R(7), R(6),
+ B(JumpIfTrue), U8(32),
+ B(ForInNext), R(3), R(7), R(4), U8(1),
+ B(JumpIfUndefined), U8(19),
+ B(Star), R(0),
+ /* 45 E> */ B(StackCheck),
+ B(Ldar), R(0),
+ B(Star), R(2),
+ /* 70 S> */ B(Ldar), R(1),
+ B(Star), R(8),
+ /* 75 E> */ B(Ldar), R(2),
+ B(Add), R(8),
+ /* 72 E> */ B(Star), R(1),
+ B(ForInStep), R(7),
+ B(Star), R(7),
+ B(Jump), U8(-33),
+ B(LdaUndefined),
+ /* 80 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -155,49 +155,49 @@
parameter count: 1
bytecode array length: 94
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Star), R(0),
- B(CreateArrayLiteral), U8(1), U8(1), U8(3),
- B(JumpIfUndefined), U8(79),
- B(JumpIfNull), U8(77),
- B(ToObject),
- B(Star), R(1),
- B(ForInPrepare), R(2),
- B(LdaZero),
- B(Star), R(5),
- B(ForInDone), R(5), R(4),
- B(JumpIfTrue), U8(64),
- B(ForInNext), R(1), R(5), R(2), U8(9),
- B(JumpIfUndefined), U8(51),
- B(Star), R(6),
- B(Ldar), R(0),
- B(Star), R(7),
- B(Ldar), R(6),
- B(StoreICSloppy), R(7), U8(2), U8(7),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(6),
- B(LoadIC), R(6), U8(2), U8(3),
- B(Star), R(7),
- B(LdaSmi), U8(10),
- B(TestEqual), R(7),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(20),
- B(Ldar), R(0),
- B(Star), R(6),
- B(LoadIC), R(6), U8(2), U8(5),
- B(Star), R(7),
- B(LdaSmi), U8(20),
- B(TestEqual), R(7),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(8),
- B(ForInStep), R(5),
- B(Star), R(5),
- B(Jump), U8(-65),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 77 S> */ B(CreateArrayLiteral), U8(1), U8(1), U8(3),
+ B(JumpIfUndefined), U8(79),
+ B(JumpIfNull), U8(77),
+ B(ToObject),
+ B(Star), R(1),
+ B(ForInPrepare), R(2),
+ B(LdaZero),
+ B(Star), R(5),
+ /* 68 S> */ B(ForInDone), R(5), R(4),
+ B(JumpIfTrue), U8(64),
+ B(ForInNext), R(1), R(5), R(2), U8(9),
+ B(JumpIfUndefined), U8(51),
+ B(Star), R(6),
+ /* 67 E> */ B(Ldar), R(0),
+ B(Star), R(7),
+ B(Ldar), R(6),
+ B(StoreICSloppy), R(7), U8(2), U8(7),
+ /* 62 E> */ B(StackCheck),
+ /* 95 S> */ B(Ldar), R(0),
+ B(Star), R(6),
+ /* 100 E> */ B(LoadIC), R(6), U8(2), U8(3),
+ B(Star), R(7),
+ B(LdaSmi), U8(10),
+ /* 106 E> */ B(TestEqual), R(7),
+ B(JumpIfFalse), U8(4),
+ /* 113 S> */ B(Jump), U8(20),
+ /* 125 S> */ B(Ldar), R(0),
+ B(Star), R(6),
+ /* 130 E> */ B(LoadIC), R(6), U8(2), U8(5),
+ B(Star), R(7),
+ B(LdaSmi), U8(20),
+ /* 136 E> */ B(TestEqual), R(7),
+ B(JumpIfFalse), U8(4),
+ /* 143 S> */ B(Jump), U8(8),
+ B(ForInStep), R(5),
+ B(Star), R(5),
+ B(Jump), U8(-65),
+ B(LdaUndefined),
+ /* 152 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -216,39 +216,39 @@
parameter count: 1
bytecode array length: 69
bytecodes: [
- B(StackCheck),
- B(CreateArrayLiteral), U8(0), U8(0), U8(3),
- B(Star), R(0),
- B(CreateArrayLiteral), U8(1), U8(1), U8(3),
- B(JumpIfUndefined), U8(56),
- B(JumpIfNull), U8(54),
- B(ToObject),
- B(Star), R(1),
- B(ForInPrepare), R(2),
- B(LdaZero),
- B(Star), R(5),
- B(ForInDone), R(5), R(4),
- B(JumpIfTrue), U8(41),
- B(ForInNext), R(1), R(5), R(2), U8(7),
- B(JumpIfUndefined), U8(28),
- B(Star), R(6),
- B(Ldar), R(0),
- B(Star), R(7),
- B(LdaZero),
- B(Star), R(8),
- B(Ldar), R(6),
- B(KeyedStoreICSloppy), R(7), R(8), U8(5),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(6),
- B(LdaSmi), U8(3),
- B(KeyedLoadIC), R(6), U8(3),
- B(Return),
- B(ForInStep), R(5),
- B(Star), R(5),
- B(Jump), U8(-42),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(CreateArrayLiteral), U8(0), U8(0), U8(3),
+ /* 42 E> */ B(Star), R(0),
+ /* 72 S> */ B(CreateArrayLiteral), U8(1), U8(1), U8(3),
+ B(JumpIfUndefined), U8(56),
+ B(JumpIfNull), U8(54),
+ B(ToObject),
+ B(Star), R(1),
+ B(ForInPrepare), R(2),
+ B(LdaZero),
+ B(Star), R(5),
+ /* 65 S> */ B(ForInDone), R(5), R(4),
+ B(JumpIfTrue), U8(41),
+ B(ForInNext), R(1), R(5), R(2), U8(7),
+ B(JumpIfUndefined), U8(28),
+ B(Star), R(6),
+ /* 64 E> */ B(Ldar), R(0),
+ B(Star), R(7),
+ B(LdaZero),
+ B(Star), R(8),
+ B(Ldar), R(6),
+ B(KeyedStoreICSloppy), R(7), R(8), U8(5),
+ /* 59 E> */ B(StackCheck),
+ /* 83 S> */ B(Ldar), R(0),
+ B(Star), R(6),
+ /* 91 E> */ B(LdaSmi), U8(3),
+ B(KeyedLoadIC), R(6), U8(3),
+ /* 98 S> */ B(Return),
+ B(ForInStep), R(5),
+ B(Star), R(5),
+ B(Jump), U8(-42),
+ B(LdaUndefined),
+ /* 98 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/ForOf.golden b/test/cctest/interpreter/bytecode_expectations/ForOf.golden
index 9b10f41..6fb1c4b 100644
--- a/test/cctest/interpreter/bytecode_expectations/ForOf.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ForOf.golden
@@ -15,157 +15,157 @@
parameter count: 1
bytecode array length: 347
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(3),
- B(Mov), R(context), R(11),
- B(Mov), R(context), R(12),
- B(CreateArrayLiteral), U8(0), U8(0), U8(3),
- B(Star), R(14),
- B(LdaConstant), U8(1),
- B(KeyedLoadIC), R(14), U8(3),
- B(Star), R(13),
- B(Call), R(13), R(14), U8(1), U8(1),
- B(Star), R(1),
- B(Ldar), R(1),
- B(Star), R(15),
- B(LoadIC), R(15), U8(2), U8(7),
- B(Star), R(14),
- B(Call), R(14), R(15), U8(1), U8(5),
- B(Star), R(2),
- B(Star), R(13),
- B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(13), U8(1),
- B(LogicalNot),
- B(JumpIfFalse), U8(11),
- B(Ldar), R(2),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(13), U8(1),
- B(Ldar), R(2),
- B(Star), R(13),
- B(LoadIC), R(13), U8(3), U8(9),
- B(JumpIfToBooleanTrue), U8(28),
- B(LdaSmi), U8(2),
- B(Star), R(3),
- B(Ldar), R(2),
- B(Star), R(13),
- B(LoadIC), R(13), U8(4), U8(11),
- B(Star), R(0),
- B(Ldar), R(4),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(7),
- B(LdaZero),
- B(Star), R(3),
- B(Jump), U8(-70),
- B(Jump), U8(47),
- B(Star), R(14),
- B(LdaConstant), U8(5),
- B(Star), R(13),
- B(Ldar), R(closure),
- B(Star), R(15),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(13), U8(3),
- B(Star), R(12),
- B(PushContext), R(8),
- B(Ldar), R(3),
- B(Star), R(13),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(13),
- B(JumpIfFalse), U8(6),
- B(LdaSmi), U8(1),
- B(Star), R(3),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::kReThrow), R(13), U8(1),
- B(PopContext), R(8),
- B(LdaSmi), U8(-1),
- B(Star), R(9),
- B(Jump), U8(7),
- B(Star), R(10),
- B(LdaZero),
- B(Star), R(9),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Star), R(11),
- B(Ldar), R(3),
- B(Star), R(12),
- B(LdaZero),
- B(TestEqualStrict), R(12),
- B(JumpIfTrue), U8(9),
- B(Ldar), R(1),
- B(Star), R(12),
- B(LdaUndefined),
- B(TestEqualStrict), R(12),
- B(LogicalNot),
- B(JumpIfFalseConstant), U8(9),
- B(Ldar), R(1),
- B(Star), R(12),
- B(LoadIC), R(12), U8(6), U8(13),
- B(Star), R(5),
- B(Star), R(12),
- B(LdaNull),
- B(TestEqual), R(12),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(124),
- B(Ldar), R(3),
- B(Star), R(12),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(12),
- B(JumpIfFalse), U8(79),
- B(Ldar), R(5),
- B(TypeOf),
- B(Star), R(12),
- B(LdaConstant), U8(7),
- B(TestEqualStrict), R(12),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(18),
- B(Wide), B(LdaSmi), U16(139),
- B(Star), R(12),
- B(LdaConstant), U8(8),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::kNewTypeError), R(12), U8(2),
- B(Throw),
- B(Mov), R(context), R(12),
- B(Ldar), R(5),
- B(Star), R(13),
- B(Ldar), R(1),
- B(Star), R(14),
- B(CallRuntime), U16(Runtime::k_Call), R(13), U8(2),
- B(Jump), U8(30),
- B(Star), R(14),
- B(LdaConstant), U8(5),
- B(Star), R(13),
- B(Ldar), R(closure),
- B(Star), R(15),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(13), U8(3),
- B(Star), R(12),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Ldar), R(12),
- B(PushContext), R(8),
- B(PopContext), R(8),
- B(Jump), U8(37),
- B(Ldar), R(5),
- B(Star), R(12),
- B(Ldar), R(1),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::k_Call), R(12), U8(2),
- B(Star), R(6),
- B(Star), R(12),
- B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(12), U8(1),
- B(JumpIfToBooleanFalse), U8(4),
- B(Jump), U8(11),
- B(Ldar), R(6),
- B(Star), R(12),
- B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(12), U8(1),
- B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(11), U8(1),
- B(LdaZero),
- B(TestEqualStrict), R(9),
- B(JumpIfTrue), U8(4),
- B(Jump), U8(5),
- B(Ldar), R(10),
- B(ReThrow),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ B(LdaUndefined),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(3),
+ B(Mov), R(context), R(11),
+ B(Mov), R(context), R(12),
+ /* 48 S> */ B(CreateArrayLiteral), U8(0), U8(0), U8(3),
+ B(Star), R(14),
+ /* 48 E> */ B(LdaConstant), U8(1),
+ B(KeyedLoadIC), R(14), U8(3),
+ B(Star), R(13),
+ /* 48 E> */ B(Call), R(13), R(14), U8(1), U8(1),
+ /* 48 E> */ B(Star), R(1),
+ /* 45 S> */ B(Ldar), R(1),
+ B(Star), R(15),
+ B(LoadIC), R(15), U8(2), U8(7),
+ B(Star), R(14),
+ /* 45 E> */ B(Call), R(14), R(15), U8(1), U8(5),
+ /* 45 E> */ B(Star), R(2),
+ B(Star), R(13),
+ B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(13), U8(1),
+ B(ToBooleanLogicalNot),
+ B(JumpIfFalse), U8(11),
+ B(Ldar), R(2),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(13), U8(1),
+ B(Ldar), R(2),
+ B(Star), R(13),
+ B(LoadIC), R(13), U8(3), U8(9),
+ B(JumpIfToBooleanTrue), U8(28),
+ B(LdaSmi), U8(2),
+ B(Star), R(3),
+ B(Ldar), R(2),
+ B(Star), R(13),
+ B(LoadIC), R(13), U8(4), U8(11),
+ B(Star), R(0),
+ B(Ldar), R(4),
+ /* 34 E> */ B(StackCheck),
+ B(Ldar), R(0),
+ B(Star), R(7),
+ B(LdaZero),
+ B(Star), R(3),
+ B(Jump), U8(-70),
+ B(Jump), U8(47),
+ B(Star), R(14),
+ B(LdaConstant), U8(5),
+ B(Star), R(13),
+ B(Ldar), R(closure),
+ B(Star), R(15),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(13), U8(3),
+ B(Star), R(12),
+ B(PushContext), R(8),
+ B(Ldar), R(3),
+ B(Star), R(13),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(13),
+ B(JumpIfFalse), U8(6),
+ B(LdaSmi), U8(1),
+ B(Star), R(3),
+ B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::kReThrow), R(13), U8(1),
+ B(PopContext), R(8),
+ B(LdaSmi), U8(-1),
+ B(Star), R(9),
+ B(Jump), U8(7),
+ B(Star), R(10),
+ B(LdaZero),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(11),
+ B(Ldar), R(3),
+ B(Star), R(12),
+ B(LdaZero),
+ B(TestEqualStrict), R(12),
+ B(JumpIfTrue), U8(9),
+ B(Ldar), R(1),
+ B(Star), R(12),
+ B(LdaUndefined),
+ B(TestEqualStrict), R(12),
+ B(ToBooleanLogicalNot),
+ B(JumpIfFalseConstant), U8(9),
+ B(Ldar), R(1),
+ B(Star), R(12),
+ B(LoadIC), R(12), U8(6), U8(13),
+ B(Star), R(5),
+ B(Star), R(12),
+ B(LdaNull),
+ B(TestEqual), R(12),
+ B(JumpIfFalse), U8(4),
+ B(Jump), U8(124),
+ B(Ldar), R(3),
+ B(Star), R(12),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(12),
+ B(JumpIfFalse), U8(79),
+ B(Ldar), R(5),
+ B(TypeOf),
+ B(Star), R(12),
+ B(LdaConstant), U8(7),
+ B(TestEqualStrict), R(12),
+ B(JumpIfFalse), U8(4),
+ B(Jump), U8(18),
+ B(Wide), B(LdaSmi), U16(129),
+ B(Star), R(12),
+ B(LdaConstant), U8(8),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::kNewTypeError), R(12), U8(2),
+ B(Throw),
+ B(Mov), R(context), R(12),
+ B(Ldar), R(5),
+ B(Star), R(13),
+ B(Ldar), R(1),
+ B(Star), R(14),
+ B(CallRuntime), U16(Runtime::k_Call), R(13), U8(2),
+ B(Jump), U8(30),
+ B(Star), R(14),
+ B(LdaConstant), U8(5),
+ B(Star), R(13),
+ B(Ldar), R(closure),
+ B(Star), R(15),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(13), U8(3),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(12),
+ B(PushContext), R(8),
+ B(PopContext), R(8),
+ B(Jump), U8(37),
+ B(Ldar), R(5),
+ B(Star), R(12),
+ B(Ldar), R(1),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::k_Call), R(12), U8(2),
+ B(Star), R(6),
+ B(Star), R(12),
+ B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(12), U8(1),
+ B(JumpIfToBooleanFalse), U8(4),
+ B(Jump), U8(11),
+ B(Ldar), R(6),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(12), U8(1),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(11), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(9),
+ B(JumpIfTrue), U8(4),
+ B(Jump), U8(5),
+ B(Ldar), R(10),
+ B(ReThrow),
+ B(LdaUndefined),
+ /* 62 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -194,166 +194,166 @@
parameter count: 1
bytecode array length: 363
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(7),
- B(LdaUndefined),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(3),
- B(Mov), R(context), R(12),
- B(Mov), R(context), R(13),
- B(Ldar), R(7),
- B(Star), R(15),
- B(LdaConstant), U8(1),
- B(KeyedLoadIC), R(15), U8(3),
- B(Star), R(14),
- B(Call), R(14), R(15), U8(1), U8(1),
- B(Star), R(1),
- B(Ldar), R(1),
- B(Star), R(16),
- B(LoadIC), R(16), U8(2), U8(7),
- B(Star), R(15),
- B(Call), R(15), R(16), U8(1), U8(5),
- B(Star), R(2),
- B(Star), R(14),
- B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(14), U8(1),
- B(LogicalNot),
- B(JumpIfFalse), U8(11),
- B(Ldar), R(2),
- B(Star), R(14),
- B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(14), U8(1),
- B(Ldar), R(2),
- B(Star), R(14),
- B(LoadIC), R(14), U8(3), U8(9),
- B(JumpIfToBooleanTrue), U8(32),
- B(LdaSmi), U8(2),
- B(Star), R(3),
- B(Ldar), R(2),
- B(Star), R(14),
- B(LoadIC), R(14), U8(4), U8(11),
- B(Star), R(0),
- B(Ldar), R(4),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(8),
- B(Star), R(11),
- B(LdaZero),
- B(Star), R(10),
- B(Jump), U8(63),
- B(Jump), U8(-74),
- B(Jump), U8(47),
- B(Star), R(15),
- B(LdaConstant), U8(5),
- B(Star), R(14),
- B(Ldar), R(closure),
- B(Star), R(16),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(14), U8(3),
- B(Star), R(13),
- B(PushContext), R(9),
- B(Ldar), R(3),
- B(Star), R(14),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(14),
- B(JumpIfFalse), U8(6),
- B(LdaSmi), U8(1),
- B(Star), R(3),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(14),
- B(CallRuntime), U16(Runtime::kReThrow), R(14), U8(1),
- B(PopContext), R(9),
- B(LdaSmi), U8(-1),
- B(Star), R(10),
- B(Jump), U8(8),
- B(Star), R(11),
- B(LdaSmi), U8(1),
- B(Star), R(10),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Star), R(12),
- B(Ldar), R(3),
- B(Star), R(13),
- B(LdaZero),
- B(TestEqualStrict), R(13),
- B(JumpIfTrue), U8(9),
- B(Ldar), R(1),
- B(Star), R(13),
- B(LdaUndefined),
- B(TestEqualStrict), R(13),
- B(LogicalNot),
- B(JumpIfFalseConstant), U8(9),
- B(Ldar), R(1),
- B(Star), R(13),
- B(LoadIC), R(13), U8(6), U8(13),
- B(Star), R(5),
- B(Star), R(13),
- B(LdaNull),
- B(TestEqual), R(13),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(124),
- B(Ldar), R(3),
- B(Star), R(13),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(13),
- B(JumpIfFalse), U8(79),
- B(Ldar), R(5),
- B(TypeOf),
- B(Star), R(13),
- B(LdaConstant), U8(7),
- B(TestEqualStrict), R(13),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(18),
- B(Wide), B(LdaSmi), U16(139),
- B(Star), R(13),
- B(LdaConstant), U8(8),
- B(Star), R(14),
- B(CallRuntime), U16(Runtime::kNewTypeError), R(13), U8(2),
- B(Throw),
- B(Mov), R(context), R(13),
- B(Ldar), R(5),
- B(Star), R(14),
- B(Ldar), R(1),
- B(Star), R(15),
- B(CallRuntime), U16(Runtime::k_Call), R(14), U8(2),
- B(Jump), U8(30),
- B(Star), R(15),
- B(LdaConstant), U8(5),
- B(Star), R(14),
- B(Ldar), R(closure),
- B(Star), R(16),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(14), U8(3),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Ldar), R(13),
- B(PushContext), R(9),
- B(PopContext), R(9),
- B(Jump), U8(37),
- B(Ldar), R(5),
- B(Star), R(13),
- B(Ldar), R(1),
- B(Star), R(14),
- B(CallRuntime), U16(Runtime::k_Call), R(13), U8(2),
- B(Star), R(6),
- B(Star), R(13),
- B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(13), U8(1),
- B(JumpIfToBooleanFalse), U8(4),
- B(Jump), U8(11),
- B(Ldar), R(6),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(13), U8(1),
- B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(12), U8(1),
- B(LdaZero),
- B(TestEqualStrict), R(10),
- B(JumpIfTrue), U8(10),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(10),
- B(JumpIfTrue), U8(7),
- B(Jump), U8(8),
- B(Ldar), R(11),
- B(Return),
- B(Ldar), R(11),
- B(ReThrow),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(7),
+ B(LdaUndefined),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(3),
+ B(Mov), R(context), R(12),
+ B(Mov), R(context), R(13),
+ /* 68 S> */ B(Ldar), R(7),
+ B(Star), R(15),
+ /* 68 E> */ B(LdaConstant), U8(1),
+ B(KeyedLoadIC), R(15), U8(3),
+ B(Star), R(14),
+ /* 68 E> */ B(Call), R(14), R(15), U8(1), U8(1),
+ /* 68 E> */ B(Star), R(1),
+ /* 65 S> */ B(Ldar), R(1),
+ B(Star), R(16),
+ B(LoadIC), R(16), U8(2), U8(7),
+ B(Star), R(15),
+ /* 65 E> */ B(Call), R(15), R(16), U8(1), U8(5),
+ /* 65 E> */ B(Star), R(2),
+ B(Star), R(14),
+ B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(14), U8(1),
+ B(ToBooleanLogicalNot),
+ B(JumpIfFalse), U8(11),
+ B(Ldar), R(2),
+ B(Star), R(14),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(14), U8(1),
+ B(Ldar), R(2),
+ B(Star), R(14),
+ B(LoadIC), R(14), U8(3), U8(9),
+ B(JumpIfToBooleanTrue), U8(32),
+ B(LdaSmi), U8(2),
+ B(Star), R(3),
+ B(Ldar), R(2),
+ B(Star), R(14),
+ B(LoadIC), R(14), U8(4), U8(11),
+ B(Star), R(0),
+ B(Ldar), R(4),
+ /* 54 E> */ B(StackCheck),
+ B(Ldar), R(0),
+ B(Star), R(8),
+ /* 73 S> */ B(Star), R(11),
+ B(LdaZero),
+ B(Star), R(10),
+ B(Jump), U8(63),
+ B(Jump), U8(-74),
+ B(Jump), U8(47),
+ B(Star), R(15),
+ B(LdaConstant), U8(5),
+ B(Star), R(14),
+ B(Ldar), R(closure),
+ B(Star), R(16),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(14), U8(3),
+ B(Star), R(13),
+ B(PushContext), R(9),
+ B(Ldar), R(3),
+ B(Star), R(14),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(14),
+ B(JumpIfFalse), U8(6),
+ B(LdaSmi), U8(1),
+ B(Star), R(3),
+ B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(14),
+ B(CallRuntime), U16(Runtime::kReThrow), R(14), U8(1),
+ B(PopContext), R(9),
+ B(LdaSmi), U8(-1),
+ B(Star), R(10),
+ B(Jump), U8(8),
+ B(Star), R(11),
+ B(LdaSmi), U8(1),
+ B(Star), R(10),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(12),
+ B(Ldar), R(3),
+ B(Star), R(13),
+ B(LdaZero),
+ B(TestEqualStrict), R(13),
+ B(JumpIfTrue), U8(9),
+ B(Ldar), R(1),
+ B(Star), R(13),
+ B(LdaUndefined),
+ B(TestEqualStrict), R(13),
+ B(ToBooleanLogicalNot),
+ B(JumpIfFalseConstant), U8(9),
+ B(Ldar), R(1),
+ B(Star), R(13),
+ B(LoadIC), R(13), U8(6), U8(13),
+ B(Star), R(5),
+ B(Star), R(13),
+ B(LdaNull),
+ B(TestEqual), R(13),
+ B(JumpIfFalse), U8(4),
+ B(Jump), U8(124),
+ B(Ldar), R(3),
+ B(Star), R(13),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(13),
+ B(JumpIfFalse), U8(79),
+ B(Ldar), R(5),
+ B(TypeOf),
+ B(Star), R(13),
+ B(LdaConstant), U8(7),
+ B(TestEqualStrict), R(13),
+ B(JumpIfFalse), U8(4),
+ B(Jump), U8(18),
+ B(Wide), B(LdaSmi), U16(129),
+ B(Star), R(13),
+ B(LdaConstant), U8(8),
+ B(Star), R(14),
+ B(CallRuntime), U16(Runtime::kNewTypeError), R(13), U8(2),
+ B(Throw),
+ B(Mov), R(context), R(13),
+ B(Ldar), R(5),
+ B(Star), R(14),
+ B(Ldar), R(1),
+ B(Star), R(15),
+ B(CallRuntime), U16(Runtime::k_Call), R(14), U8(2),
+ B(Jump), U8(30),
+ B(Star), R(15),
+ B(LdaConstant), U8(5),
+ B(Star), R(14),
+ B(Ldar), R(closure),
+ B(Star), R(16),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(14), U8(3),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(13),
+ B(PushContext), R(9),
+ B(PopContext), R(9),
+ B(Jump), U8(37),
+ B(Ldar), R(5),
+ B(Star), R(13),
+ B(Ldar), R(1),
+ B(Star), R(14),
+ B(CallRuntime), U16(Runtime::k_Call), R(13), U8(2),
+ B(Star), R(6),
+ B(Star), R(13),
+ B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(13), U8(1),
+ B(JumpIfToBooleanFalse), U8(4),
+ B(Jump), U8(11),
+ B(Ldar), R(6),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(13), U8(1),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(12), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(10),
+ B(JumpIfTrue), U8(10),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(10),
+ B(JumpIfTrue), U8(7),
+ B(Jump), U8(8),
+ B(Ldar), R(11),
+ /* 85 S> */ B(Return),
+ B(Ldar), R(11),
+ B(ReThrow),
+ B(LdaUndefined),
+ /* 85 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -384,168 +384,168 @@
parameter count: 1
bytecode array length: 369
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(3),
- B(Mov), R(context), R(11),
- B(Mov), R(context), R(12),
- B(CreateArrayLiteral), U8(0), U8(0), U8(3),
- B(Star), R(14),
- B(LdaConstant), U8(1),
- B(KeyedLoadIC), R(14), U8(3),
- B(Star), R(13),
- B(Call), R(13), R(14), U8(1), U8(1),
- B(Star), R(1),
- B(Ldar), R(1),
- B(Star), R(15),
- B(LoadIC), R(15), U8(2), U8(7),
- B(Star), R(14),
- B(Call), R(14), R(15), U8(1), U8(5),
- B(Star), R(2),
- B(Star), R(13),
- B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(13), U8(1),
- B(LogicalNot),
- B(JumpIfFalse), U8(11),
- B(Ldar), R(2),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(13), U8(1),
- B(Ldar), R(2),
- B(Star), R(13),
- B(LoadIC), R(13), U8(3), U8(9),
- B(JumpIfToBooleanTrue), U8(50),
- B(LdaSmi), U8(2),
- B(Star), R(3),
- B(Ldar), R(2),
- B(Star), R(13),
- B(LoadIC), R(13), U8(4), U8(11),
- B(Star), R(0),
- B(Ldar), R(4),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(7),
- B(Star), R(13),
- B(LdaSmi), U8(10),
- B(TestEqual), R(13),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(-75),
- B(Ldar), R(7),
- B(Star), R(13),
- B(LdaSmi), U8(20),
- B(TestEqual), R(13),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(7),
- B(LdaZero),
- B(Star), R(3),
- B(Jump), U8(-92),
- B(Jump), U8(47),
- B(Star), R(14),
- B(LdaConstant), U8(5),
- B(Star), R(13),
- B(Ldar), R(closure),
- B(Star), R(15),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(13), U8(3),
- B(Star), R(12),
- B(PushContext), R(8),
- B(Ldar), R(3),
- B(Star), R(13),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(13),
- B(JumpIfFalse), U8(6),
- B(LdaSmi), U8(1),
- B(Star), R(3),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::kReThrow), R(13), U8(1),
- B(PopContext), R(8),
- B(LdaSmi), U8(-1),
- B(Star), R(9),
- B(Jump), U8(7),
- B(Star), R(10),
- B(LdaZero),
- B(Star), R(9),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Star), R(11),
- B(Ldar), R(3),
- B(Star), R(12),
- B(LdaZero),
- B(TestEqualStrict), R(12),
- B(JumpIfTrue), U8(9),
- B(Ldar), R(1),
- B(Star), R(12),
- B(LdaUndefined),
- B(TestEqualStrict), R(12),
- B(LogicalNot),
- B(JumpIfFalseConstant), U8(9),
- B(Ldar), R(1),
- B(Star), R(12),
- B(LoadIC), R(12), U8(6), U8(13),
- B(Star), R(5),
- B(Star), R(12),
- B(LdaNull),
- B(TestEqual), R(12),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(124),
- B(Ldar), R(3),
- B(Star), R(12),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(12),
- B(JumpIfFalse), U8(79),
- B(Ldar), R(5),
- B(TypeOf),
- B(Star), R(12),
- B(LdaConstant), U8(7),
- B(TestEqualStrict), R(12),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(18),
- B(Wide), B(LdaSmi), U16(139),
- B(Star), R(12),
- B(LdaConstant), U8(8),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::kNewTypeError), R(12), U8(2),
- B(Throw),
- B(Mov), R(context), R(12),
- B(Ldar), R(5),
- B(Star), R(13),
- B(Ldar), R(1),
- B(Star), R(14),
- B(CallRuntime), U16(Runtime::k_Call), R(13), U8(2),
- B(Jump), U8(30),
- B(Star), R(14),
- B(LdaConstant), U8(5),
- B(Star), R(13),
- B(Ldar), R(closure),
- B(Star), R(15),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(13), U8(3),
- B(Star), R(12),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Ldar), R(12),
- B(PushContext), R(8),
- B(PopContext), R(8),
- B(Jump), U8(37),
- B(Ldar), R(5),
- B(Star), R(12),
- B(Ldar), R(1),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::k_Call), R(12), U8(2),
- B(Star), R(6),
- B(Star), R(12),
- B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(12), U8(1),
- B(JumpIfToBooleanFalse), U8(4),
- B(Jump), U8(11),
- B(Ldar), R(6),
- B(Star), R(12),
- B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(12), U8(1),
- B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(11), U8(1),
- B(LdaZero),
- B(TestEqualStrict), R(9),
- B(JumpIfTrue), U8(4),
- B(Jump), U8(5),
- B(Ldar), R(10),
- B(ReThrow),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ B(LdaUndefined),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(3),
+ B(Mov), R(context), R(11),
+ B(Mov), R(context), R(12),
+ /* 48 S> */ B(CreateArrayLiteral), U8(0), U8(0), U8(3),
+ B(Star), R(14),
+ /* 48 E> */ B(LdaConstant), U8(1),
+ B(KeyedLoadIC), R(14), U8(3),
+ B(Star), R(13),
+ /* 48 E> */ B(Call), R(13), R(14), U8(1), U8(1),
+ /* 48 E> */ B(Star), R(1),
+ /* 45 S> */ B(Ldar), R(1),
+ B(Star), R(15),
+ B(LoadIC), R(15), U8(2), U8(7),
+ B(Star), R(14),
+ /* 45 E> */ B(Call), R(14), R(15), U8(1), U8(5),
+ /* 45 E> */ B(Star), R(2),
+ B(Star), R(13),
+ B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(13), U8(1),
+ B(ToBooleanLogicalNot),
+ B(JumpIfFalse), U8(11),
+ B(Ldar), R(2),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(13), U8(1),
+ B(Ldar), R(2),
+ B(Star), R(13),
+ B(LoadIC), R(13), U8(3), U8(9),
+ B(JumpIfToBooleanTrue), U8(50),
+ B(LdaSmi), U8(2),
+ B(Star), R(3),
+ B(Ldar), R(2),
+ B(Star), R(13),
+ B(LoadIC), R(13), U8(4), U8(11),
+ B(Star), R(0),
+ B(Ldar), R(4),
+ /* 34 E> */ B(StackCheck),
+ B(Ldar), R(0),
+ B(Star), R(7),
+ /* 66 S> */ B(Star), R(13),
+ B(LdaSmi), U8(10),
+ /* 72 E> */ B(TestEqual), R(13),
+ B(JumpIfFalse), U8(4),
+ /* 79 S> */ B(Jump), U8(17),
+ /* 91 S> */ B(Ldar), R(7),
+ B(Star), R(13),
+ B(LdaSmi), U8(20),
+ /* 97 E> */ B(TestEqual), R(13),
+ B(JumpIfFalse), U8(4),
+ /* 104 S> */ B(Jump), U8(7),
+ B(LdaZero),
+ B(Star), R(3),
+ B(Jump), U8(-92),
+ B(Jump), U8(47),
+ B(Star), R(14),
+ B(LdaConstant), U8(5),
+ B(Star), R(13),
+ B(Ldar), R(closure),
+ B(Star), R(15),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(13), U8(3),
+ B(Star), R(12),
+ B(PushContext), R(8),
+ B(Ldar), R(3),
+ B(Star), R(13),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(13),
+ B(JumpIfFalse), U8(6),
+ B(LdaSmi), U8(1),
+ B(Star), R(3),
+ B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::kReThrow), R(13), U8(1),
+ B(PopContext), R(8),
+ B(LdaSmi), U8(-1),
+ B(Star), R(9),
+ B(Jump), U8(7),
+ B(Star), R(10),
+ B(LdaZero),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(11),
+ B(Ldar), R(3),
+ B(Star), R(12),
+ B(LdaZero),
+ B(TestEqualStrict), R(12),
+ B(JumpIfTrue), U8(9),
+ B(Ldar), R(1),
+ B(Star), R(12),
+ B(LdaUndefined),
+ B(TestEqualStrict), R(12),
+ B(ToBooleanLogicalNot),
+ B(JumpIfFalseConstant), U8(9),
+ B(Ldar), R(1),
+ B(Star), R(12),
+ B(LoadIC), R(12), U8(6), U8(13),
+ B(Star), R(5),
+ B(Star), R(12),
+ B(LdaNull),
+ B(TestEqual), R(12),
+ B(JumpIfFalse), U8(4),
+ B(Jump), U8(124),
+ B(Ldar), R(3),
+ B(Star), R(12),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(12),
+ B(JumpIfFalse), U8(79),
+ B(Ldar), R(5),
+ B(TypeOf),
+ B(Star), R(12),
+ B(LdaConstant), U8(7),
+ B(TestEqualStrict), R(12),
+ B(JumpIfFalse), U8(4),
+ B(Jump), U8(18),
+ B(Wide), B(LdaSmi), U16(129),
+ B(Star), R(12),
+ B(LdaConstant), U8(8),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::kNewTypeError), R(12), U8(2),
+ B(Throw),
+ B(Mov), R(context), R(12),
+ B(Ldar), R(5),
+ B(Star), R(13),
+ B(Ldar), R(1),
+ B(Star), R(14),
+ B(CallRuntime), U16(Runtime::k_Call), R(13), U8(2),
+ B(Jump), U8(30),
+ B(Star), R(14),
+ B(LdaConstant), U8(5),
+ B(Star), R(13),
+ B(Ldar), R(closure),
+ B(Star), R(15),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(13), U8(3),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(12),
+ B(PushContext), R(8),
+ B(PopContext), R(8),
+ B(Jump), U8(37),
+ B(Ldar), R(5),
+ B(Star), R(12),
+ B(Ldar), R(1),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::k_Call), R(12), U8(2),
+ B(Star), R(6),
+ B(Star), R(12),
+ B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(12), U8(1),
+ B(JumpIfToBooleanFalse), U8(4),
+ B(Jump), U8(11),
+ B(Ldar), R(6),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(12), U8(1),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(11), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(9),
+ B(JumpIfTrue), U8(4),
+ B(Jump), U8(5),
+ B(Ldar), R(10),
+ B(ReThrow),
+ B(LdaUndefined),
+ /* 113 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -574,170 +574,170 @@
parameter count: 1
bytecode array length: 379
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(8),
- B(Star), R(6),
- B(LdaUndefined),
- B(Star), R(3),
- B(LdaZero),
- B(Star), R(2),
- B(Mov), R(context), R(10),
- B(Mov), R(context), R(11),
- B(CreateArrayLiteral), U8(1), U8(1), U8(3),
- B(Star), R(13),
- B(LdaConstant), U8(2),
- B(KeyedLoadIC), R(13), U8(3),
- B(Star), R(12),
- B(Call), R(12), R(13), U8(1), U8(1),
- B(Star), R(0),
- B(Ldar), R(0),
- B(Star), R(14),
- B(LoadIC), R(14), U8(3), U8(7),
- B(Star), R(13),
- B(Call), R(13), R(14), U8(1), U8(5),
- B(Star), R(1),
- B(Star), R(12),
- B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(12), U8(1),
- B(LogicalNot),
- B(JumpIfFalse), U8(11),
- B(Ldar), R(1),
- B(Star), R(12),
- B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(12), U8(1),
- B(Ldar), R(1),
- B(Star), R(12),
- B(LoadIC), R(12), U8(4), U8(9),
- B(JumpIfToBooleanTrue), U8(42),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(Ldar), R(6),
- B(Star), R(12),
- B(Ldar), R(1),
- B(Star), R(13),
- B(LoadIC), R(13), U8(5), U8(11),
- B(StoreICSloppy), R(12), U8(6), U8(13),
- B(Ldar), R(3),
- B(StackCheck),
- B(Ldar), R(6),
- B(Star), R(12),
- B(LoadIC), R(12), U8(6), U8(15),
- B(Star), R(9),
- B(LdaZero),
- B(Star), R(8),
- B(Jump), U8(63),
- B(Jump), U8(-84),
- B(Jump), U8(47),
- B(Star), R(13),
- B(LdaConstant), U8(7),
- B(Star), R(12),
- B(Ldar), R(closure),
- B(Star), R(14),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(12), U8(3),
- B(Star), R(11),
- B(PushContext), R(7),
- B(Ldar), R(2),
- B(Star), R(12),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(12),
- B(JumpIfFalse), U8(6),
- B(LdaSmi), U8(1),
- B(Star), R(2),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(12),
- B(CallRuntime), U16(Runtime::kReThrow), R(12), U8(1),
- B(PopContext), R(7),
- B(LdaSmi), U8(-1),
- B(Star), R(8),
- B(Jump), U8(8),
- B(Star), R(9),
- B(LdaSmi), U8(1),
- B(Star), R(8),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Star), R(10),
- B(Ldar), R(2),
- B(Star), R(11),
- B(LdaZero),
- B(TestEqualStrict), R(11),
- B(JumpIfTrue), U8(9),
- B(Ldar), R(0),
- B(Star), R(11),
- B(LdaUndefined),
- B(TestEqualStrict), R(11),
- B(LogicalNot),
- B(JumpIfFalseConstant), U8(11),
- B(Ldar), R(0),
- B(Star), R(11),
- B(LoadIC), R(11), U8(8), U8(17),
- B(Star), R(4),
- B(Star), R(11),
- B(LdaNull),
- B(TestEqual), R(11),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(124),
- B(Ldar), R(2),
- B(Star), R(11),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(11),
- B(JumpIfFalse), U8(79),
- B(Ldar), R(4),
- B(TypeOf),
- B(Star), R(11),
- B(LdaConstant), U8(9),
- B(TestEqualStrict), R(11),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(18),
- B(Wide), B(LdaSmi), U16(139),
- B(Star), R(11),
- B(LdaConstant), U8(10),
- B(Star), R(12),
- B(CallRuntime), U16(Runtime::kNewTypeError), R(11), U8(2),
- B(Throw),
- B(Mov), R(context), R(11),
- B(Ldar), R(4),
- B(Star), R(12),
- B(Ldar), R(0),
- B(Star), R(13),
- B(CallRuntime), U16(Runtime::k_Call), R(12), U8(2),
- B(Jump), U8(30),
- B(Star), R(13),
- B(LdaConstant), U8(7),
- B(Star), R(12),
- B(Ldar), R(closure),
- B(Star), R(14),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(12), U8(3),
- B(Star), R(11),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Ldar), R(11),
- B(PushContext), R(7),
- B(PopContext), R(7),
- B(Jump), U8(37),
- B(Ldar), R(4),
- B(Star), R(11),
- B(Ldar), R(0),
- B(Star), R(12),
- B(CallRuntime), U16(Runtime::k_Call), R(11), U8(2),
- B(Star), R(5),
- B(Star), R(11),
- B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(11), U8(1),
- B(JumpIfToBooleanFalse), U8(4),
- B(Jump), U8(11),
- B(Ldar), R(5),
- B(Star), R(11),
- B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(11), U8(1),
- B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(10), U8(1),
- B(LdaZero),
- B(TestEqualStrict), R(8),
- B(JumpIfTrue), U8(10),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(8),
- B(JumpIfTrue), U8(7),
- B(Jump), U8(8),
- B(Ldar), R(9),
- B(Return),
- B(Ldar), R(9),
- B(ReThrow),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(8),
+ /* 42 E> */ B(Star), R(6),
+ B(LdaUndefined),
+ B(Star), R(3),
+ B(LdaZero),
+ B(Star), R(2),
+ B(Mov), R(context), R(10),
+ B(Mov), R(context), R(11),
+ /* 77 S> */ B(CreateArrayLiteral), U8(1), U8(1), U8(3),
+ B(Star), R(13),
+ /* 77 E> */ B(LdaConstant), U8(2),
+ B(KeyedLoadIC), R(13), U8(3),
+ B(Star), R(12),
+ /* 77 E> */ B(Call), R(12), R(13), U8(1), U8(1),
+ /* 77 E> */ B(Star), R(0),
+ /* 74 S> */ B(Ldar), R(0),
+ B(Star), R(14),
+ B(LoadIC), R(14), U8(3), U8(7),
+ B(Star), R(13),
+ /* 74 E> */ B(Call), R(13), R(14), U8(1), U8(5),
+ /* 74 E> */ B(Star), R(1),
+ B(Star), R(12),
+ B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(12), U8(1),
+ B(ToBooleanLogicalNot),
+ B(JumpIfFalse), U8(11),
+ B(Ldar), R(1),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(12), U8(1),
+ B(Ldar), R(1),
+ B(Star), R(12),
+ B(LoadIC), R(12), U8(4), U8(9),
+ B(JumpIfToBooleanTrue), U8(42),
+ B(LdaSmi), U8(2),
+ B(Star), R(2),
+ /* 67 E> */ B(Ldar), R(6),
+ B(Star), R(12),
+ B(Ldar), R(1),
+ B(Star), R(13),
+ B(LoadIC), R(13), U8(5), U8(11),
+ B(StoreICSloppy), R(12), U8(6), U8(13),
+ B(Ldar), R(3),
+ /* 62 E> */ B(StackCheck),
+ /* 88 S> */ B(Ldar), R(6),
+ B(Star), R(12),
+ /* 96 E> */ B(LoadIC), R(12), U8(6), U8(15),
+ B(Star), R(9),
+ B(LdaZero),
+ B(Star), R(8),
+ B(Jump), U8(63),
+ B(Jump), U8(-84),
+ B(Jump), U8(47),
+ B(Star), R(13),
+ B(LdaConstant), U8(7),
+ B(Star), R(12),
+ B(Ldar), R(closure),
+ B(Star), R(14),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(12), U8(3),
+ B(Star), R(11),
+ B(PushContext), R(7),
+ B(Ldar), R(2),
+ B(Star), R(12),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(12),
+ B(JumpIfFalse), U8(6),
+ B(LdaSmi), U8(1),
+ B(Star), R(2),
+ B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kReThrow), R(12), U8(1),
+ B(PopContext), R(7),
+ B(LdaSmi), U8(-1),
+ B(Star), R(8),
+ B(Jump), U8(8),
+ B(Star), R(9),
+ B(LdaSmi), U8(1),
+ B(Star), R(8),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(10),
+ B(Ldar), R(2),
+ B(Star), R(11),
+ B(LdaZero),
+ B(TestEqualStrict), R(11),
+ B(JumpIfTrue), U8(9),
+ B(Ldar), R(0),
+ B(Star), R(11),
+ B(LdaUndefined),
+ B(TestEqualStrict), R(11),
+ B(ToBooleanLogicalNot),
+ B(JumpIfFalseConstant), U8(11),
+ B(Ldar), R(0),
+ B(Star), R(11),
+ B(LoadIC), R(11), U8(8), U8(17),
+ B(Star), R(4),
+ B(Star), R(11),
+ B(LdaNull),
+ B(TestEqual), R(11),
+ B(JumpIfFalse), U8(4),
+ B(Jump), U8(124),
+ B(Ldar), R(2),
+ B(Star), R(11),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(11),
+ B(JumpIfFalse), U8(79),
+ B(Ldar), R(4),
+ B(TypeOf),
+ B(Star), R(11),
+ B(LdaConstant), U8(9),
+ B(TestEqualStrict), R(11),
+ B(JumpIfFalse), U8(4),
+ B(Jump), U8(18),
+ B(Wide), B(LdaSmi), U16(129),
+ B(Star), R(11),
+ B(LdaConstant), U8(10),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kNewTypeError), R(11), U8(2),
+ B(Throw),
+ B(Mov), R(context), R(11),
+ B(Ldar), R(4),
+ B(Star), R(12),
+ B(Ldar), R(0),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::k_Call), R(12), U8(2),
+ B(Jump), U8(30),
+ B(Star), R(13),
+ B(LdaConstant), U8(7),
+ B(Star), R(12),
+ B(Ldar), R(closure),
+ B(Star), R(14),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(12), U8(3),
+ B(Star), R(11),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(11),
+ B(PushContext), R(7),
+ B(PopContext), R(7),
+ B(Jump), U8(37),
+ B(Ldar), R(4),
+ B(Star), R(11),
+ B(Ldar), R(0),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::k_Call), R(11), U8(2),
+ B(Star), R(5),
+ B(Star), R(11),
+ B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(11), U8(1),
+ B(JumpIfToBooleanFalse), U8(4),
+ B(Jump), U8(11),
+ B(Ldar), R(5),
+ B(Star), R(11),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(11), U8(1),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(10), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(8),
+ B(JumpIfTrue), U8(10),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(8),
+ B(JumpIfTrue), U8(7),
+ B(Jump), U8(8),
+ B(Ldar), R(9),
+ /* 105 S> */ B(Return),
+ B(Ldar), R(9),
+ B(ReThrow),
+ B(LdaUndefined),
+ /* 105 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/FunctionLiterals.golden b/test/cctest/interpreter/bytecode_expectations/FunctionLiterals.golden
index fe7176c..f6b863f 100644
--- a/test/cctest/interpreter/bytecode_expectations/FunctionLiterals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/FunctionLiterals.golden
@@ -15,9 +15,9 @@
parameter count: 1
bytecode array length: 5
bytecodes: [
- B(StackCheck),
- B(CreateClosure), U8(0), U8(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateClosure), U8(0), U8(0),
+ /* 55 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -33,13 +33,13 @@
parameter count: 1
bytecode array length: 15
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Star), R(1),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(Call), R(0), R(1), U8(1), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaUndefined),
+ B(Star), R(1),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 56 E> */ B(Call), R(0), R(1), U8(1), U8(1),
+ /* 59 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -55,15 +55,15 @@
parameter count: 1
bytecode array length: 19
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Star), R(1),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Star), R(2),
- B(Call), R(0), R(1), U8(2), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaUndefined),
+ B(Star), R(1),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ B(Star), R(2),
+ /* 67 E> */ B(Call), R(0), R(1), U8(2), U8(1),
+ /* 71 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/Generators.golden b/test/cctest/interpreter/bytecode_expectations/Generators.golden
new file mode 100644
index 0000000..46a6b4a
--- /dev/null
+++ b/test/cctest/interpreter/bytecode_expectations/Generators.golden
@@ -0,0 +1,646 @@
+#
+# Autogenerated by generate-bytecode-expectations.
+#
+
+---
+pool type: mixed
+execute: yes
+wrap: no
+test function name: f
+ignition generators: yes
+
+---
+snippet: "
+ function* f() { }
+"
+frame size: 11
+parameter count: 1
+bytecode array length: 203
+bytecodes: [
+ B(Ldar), R(new_target),
+ B(JumpIfUndefined), U8(20),
+ B(ResumeGenerator), R(new_target),
+ B(Star), R(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(1),
+ B(JumpIfTrue), U8(57),
+ B(LdaSmi), U8(76),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kAbort), R(2), U8(1),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(this),
+ B(StaContextSlot), R(context), U8(4),
+ /* 11 E> */ B(StackCheck),
+ B(Mov), R(context), R(4),
+ B(Ldar), R(closure),
+ B(Star), R(5),
+ B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kCreateJSGeneratorObject), R(5), U8(2),
+ B(StaContextSlot), R(context), U8(5),
+ B(Star), R(5),
+ B(LdaContextSlot), R(context), U8(5),
+ B(Star), R(6),
+ B(LdaZero),
+ B(SuspendGenerator), R(6),
+ B(Ldar), R(5),
+ /* 16 S> */ B(Return),
+ B(LdaSmi), U8(-2),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kGeneratorGetInput), R(6), U8(1),
+ B(Star), R(7),
+ B(CallRuntime), U16(Runtime::kGeneratorGetResumeMode), R(6), U8(1),
+ B(Star), R(8),
+ B(LdaZero),
+ B(TestEqualStrict), R(8),
+ B(JumpIfTrue), U8(31),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(8),
+ B(JumpIfTrue), U8(22),
+ B(Jump), U8(2),
+ B(Mov), R(7), R(9),
+ B(LdaTrue),
+ B(Star), R(10),
+ B(CallRuntime), U16(Runtime::kCreateIterResultObject), R(9), U8(2),
+ B(Star), R(3),
+ B(LdaZero),
+ B(Star), R(2),
+ B(Jump), U8(36),
+ B(Ldar), R(7),
+ B(Throw),
+ B(LdaUndefined),
+ B(Star), R(5),
+ B(LdaTrue),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(5), U8(2),
+ B(Star), R(3),
+ B(LdaSmi), U8(1),
+ B(Star), R(2),
+ B(Jump), U8(14),
+ B(LdaSmi), U8(-1),
+ B(Star), R(2),
+ B(Jump), U8(8),
+ B(Star), R(3),
+ B(LdaSmi), U8(2),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(4),
+ B(LdaContextSlot), R(context), U8(5),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kGeneratorClose), R(5), U8(1),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(4), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(16),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(13),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(10),
+ B(Jump), U8(11),
+ B(Ldar), R(3),
+ /* 16 S> */ B(Return),
+ B(Ldar), R(3),
+ /* 16 S> */ B(Return),
+ B(Ldar), R(3),
+ B(ReThrow),
+ B(LdaUndefined),
+ /* 16 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+ [38, 139, 145],
+]
+
+---
+snippet: "
+ function* f() { yield 42 }
+"
+frame size: 11
+parameter count: 1
+bytecode array length: 297
+bytecodes: [
+ B(Ldar), R(new_target),
+ B(JumpIfUndefined), U8(26),
+ B(ResumeGenerator), R(new_target),
+ B(Star), R(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(1),
+ B(JumpIfTrue), U8(63),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(1),
+ B(JumpIfTrueConstant), U8(0),
+ B(LdaSmi), U8(76),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kAbort), R(2), U8(1),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(this),
+ B(StaContextSlot), R(context), U8(4),
+ /* 11 E> */ B(StackCheck),
+ B(Mov), R(context), R(4),
+ B(Ldar), R(closure),
+ B(Star), R(5),
+ B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kCreateJSGeneratorObject), R(5), U8(2),
+ B(StaContextSlot), R(context), U8(5),
+ B(Star), R(5),
+ B(LdaContextSlot), R(context), U8(5),
+ B(Star), R(6),
+ B(LdaZero),
+ B(SuspendGenerator), R(6),
+ B(Ldar), R(5),
+ /* 25 S> */ B(Return),
+ B(LdaSmi), U8(-2),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kGeneratorGetInput), R(6), U8(1),
+ B(Star), R(7),
+ B(CallRuntime), U16(Runtime::kGeneratorGetResumeMode), R(6), U8(1),
+ B(Star), R(8),
+ B(LdaZero),
+ B(TestEqualStrict), R(8),
+ B(JumpIfTrue), U8(31),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(8),
+ B(JumpIfTrue), U8(22),
+ B(Jump), U8(2),
+ B(Mov), R(7), R(9),
+ B(LdaTrue),
+ B(Star), R(10),
+ B(CallRuntime), U16(Runtime::kCreateIterResultObject), R(9), U8(2),
+ B(Star), R(3),
+ B(LdaZero),
+ B(Star), R(2),
+ B(Jump), U8(115),
+ B(Ldar), R(7),
+ B(Throw),
+ /* 16 S> */ B(LdaSmi), U8(42),
+ B(Star), R(5),
+ B(LdaFalse),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(5), U8(2),
+ B(Star), R(7),
+ B(LdaContextSlot), R(context), U8(5),
+ B(Star), R(5),
+ B(LdaSmi), U8(1),
+ B(SuspendGenerator), R(5),
+ B(Ldar), R(7),
+ /* 25 S> */ B(Return),
+ B(LdaSmi), U8(-2),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kGeneratorGetInput), R(5), U8(1),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kGeneratorGetResumeMode), R(5), U8(1),
+ B(Star), R(8),
+ B(LdaZero),
+ B(TestEqualStrict), R(8),
+ B(JumpIfTrue), U8(32),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(8),
+ B(JumpIfTrue), U8(23),
+ B(Jump), U8(2),
+ B(Mov), R(6), R(9),
+ B(LdaTrue),
+ B(Star), R(10),
+ B(CallRuntime), U16(Runtime::kCreateIterResultObject), R(9), U8(2),
+ B(Star), R(3),
+ B(LdaSmi), U8(1),
+ B(Star), R(2),
+ B(Jump), U8(36),
+ B(Ldar), R(6),
+ B(Throw),
+ B(LdaUndefined),
+ B(Star), R(5),
+ B(LdaTrue),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(5), U8(2),
+ B(Star), R(3),
+ B(LdaSmi), U8(2),
+ B(Star), R(2),
+ B(Jump), U8(14),
+ B(LdaSmi), U8(-1),
+ B(Star), R(2),
+ B(Jump), U8(8),
+ B(Star), R(3),
+ B(LdaSmi), U8(3),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(4),
+ B(LdaContextSlot), R(context), U8(5),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kGeneratorClose), R(5), U8(1),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(4), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(22),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(19),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(16),
+ B(LdaSmi), U8(3),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(13),
+ B(Jump), U8(14),
+ B(Ldar), R(3),
+ /* 25 S> */ B(Return),
+ B(Ldar), R(3),
+ /* 25 S> */ B(Return),
+ B(Ldar), R(3),
+ /* 25 S> */ B(Return),
+ B(Ldar), R(3),
+ B(ReThrow),
+ B(LdaUndefined),
+ /* 25 S> */ B(Return),
+]
+constant pool: [
+ kInstanceTypeDontCare,
+]
+handlers: [
+ [44, 224, 230],
+]
+
+---
+snippet: "
+ function* f() { for (let x of [42]) yield x }
+"
+frame size: 17
+parameter count: 1
+bytecode array length: 808
+bytecodes: [
+ B(Ldar), R(new_target),
+ B(JumpIfUndefined), U8(26),
+ B(ResumeGenerator), R(new_target),
+ B(Star), R(3),
+ B(LdaZero),
+ B(TestEqualStrict), R(3),
+ B(JumpIfTrue), U8(63),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(3),
+ B(JumpIfTrueConstant), U8(3),
+ B(LdaSmi), U8(76),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kAbort), R(4), U8(1),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(this),
+ B(StaContextSlot), R(context), U8(4),
+ /* 11 E> */ B(StackCheck),
+ B(Mov), R(context), R(6),
+ B(Ldar), R(closure),
+ B(Star), R(7),
+ B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(8),
+ B(CallRuntime), U16(Runtime::kCreateJSGeneratorObject), R(7), U8(2),
+ B(StaContextSlot), R(context), U8(5),
+ B(Star), R(7),
+ B(LdaContextSlot), R(context), U8(5),
+ B(Star), R(8),
+ B(LdaZero),
+ B(SuspendGenerator), R(8),
+ B(Ldar), R(7),
+ /* 44 S> */ B(Return),
+ B(LdaSmi), U8(-2),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kGeneratorGetInput), R(8), U8(1),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kGeneratorGetResumeMode), R(8), U8(1),
+ B(Star), R(10),
+ B(LdaZero),
+ B(TestEqualStrict), R(10),
+ B(JumpIfTrue), U8(31),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(10),
+ B(JumpIfTrue), U8(22),
+ B(Jump), U8(2),
+ B(Mov), R(9), R(11),
+ B(LdaTrue),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kCreateIterResultObject), R(11), U8(2),
+ B(Star), R(5),
+ B(LdaZero),
+ B(Star), R(4),
+ B(JumpConstant), U8(17),
+ B(Ldar), R(9),
+ B(Throw),
+ B(LdaConstant), U8(0),
+ B(Star), R(7),
+ B(Ldar), R(closure),
+ B(Star), R(8),
+ B(CallRuntime), U16(Runtime::kPushBlockContext), R(7), U8(2),
+ B(PushContext), R(1),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(LdaUndefined),
+ B(StaContextSlot), R(1), U8(10),
+ B(LdaZero),
+ B(StaContextSlot), R(1), U8(9),
+ B(Mov), R(context), R(9),
+ B(Mov), R(context), R(10),
+ /* 30 S> */ B(CreateArrayLiteral), U8(1), U8(0), U8(3),
+ B(Star), R(12),
+ /* 30 E> */ B(LdaConstant), U8(2),
+ B(KeyedLoadIC), R(12), U8(3),
+ B(Star), R(11),
+ /* 30 E> */ B(Call), R(11), R(12), U8(1), U8(1),
+ /* 30 E> */ B(StaContextSlot), R(1), U8(7),
+ B(LdaSmi), U8(-2),
+ B(TestEqual), R(3),
+ B(JumpIfTrue), U8(17),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(3),
+ B(JumpIfTrueConstant), U8(9),
+ B(LdaSmi), U8(76),
+ B(Star), R(11),
+ B(CallRuntime), U16(Runtime::kAbort), R(11), U8(1),
+ /* 27 S> */ B(LdaContextSlot), R(1), U8(7),
+ B(Star), R(13),
+ B(LoadIC), R(13), U8(4), U8(7),
+ B(Star), R(12),
+ /* 27 E> */ B(Call), R(12), R(13), U8(1), U8(5),
+ /* 27 E> */ B(StaContextSlot), R(1), U8(8),
+ B(Star), R(11),
+ B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(11), U8(1),
+ B(ToBooleanLogicalNot),
+ B(JumpIfFalse), U8(12),
+ B(LdaContextSlot), R(1), U8(8),
+ B(Star), R(11),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(11), U8(1),
+ B(LdaContextSlot), R(1), U8(8),
+ B(Star), R(11),
+ B(LoadIC), R(11), U8(5), U8(9),
+ B(JumpIfToBooleanTrueConstant), U8(10),
+ B(LdaSmi), U8(2),
+ B(StaContextSlot), R(1), U8(9),
+ B(LdaContextSlot), R(1), U8(8),
+ B(Star), R(11),
+ B(LoadIC), R(11), U8(6), U8(11),
+ B(StaContextSlot), R(1), U8(6),
+ B(LdaContextSlot), R(1), U8(10),
+ /* 16 E> */ B(StackCheck),
+ B(LdaConstant), U8(7),
+ B(Star), R(11),
+ B(Ldar), R(closure),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kPushBlockContext), R(11), U8(2),
+ B(PushContext), R(2),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(LdaContextSlot), R(1), U8(6),
+ B(StaContextSlot), R(context), U8(4),
+ /* 36 S> */ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(8),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(12), U8(1),
+ B(Star), R(11),
+ B(LdaFalse),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(11), U8(2),
+ B(Star), R(13),
+ B(LdaContextSlot), R(1), U8(5),
+ B(Star), R(11),
+ B(LdaSmi), U8(1),
+ B(SuspendGenerator), R(11),
+ B(Ldar), R(13),
+ /* 44 S> */ B(Return),
+ B(LdaSmi), U8(-2),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kGeneratorGetInput), R(11), U8(1),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::kGeneratorGetResumeMode), R(11), U8(1),
+ B(Star), R(14),
+ B(LdaZero),
+ B(TestEqualStrict), R(14),
+ B(JumpIfTrue), U8(45),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(14),
+ B(JumpIfTrue), U8(36),
+ B(Jump), U8(2),
+ B(Mov), R(12), R(15),
+ B(LdaTrue),
+ B(Star), R(16),
+ B(CallRuntime), U16(Runtime::kCreateIterResultObject), R(15), U8(2),
+ B(PopContext), R(2),
+ B(PopContext), R(2),
+ B(PopContext), R(2),
+ B(PopContext), R(2),
+ B(PopContext), R(2),
+ B(PopContext), R(2),
+ B(PopContext), R(2),
+ B(Star), R(8),
+ B(LdaZero),
+ B(Star), R(7),
+ B(Jump), U8(78),
+ B(Ldar), R(12),
+ B(Throw),
+ B(Ldar), R(12),
+ B(PopContext), R(2),
+ B(LdaZero),
+ B(StaContextSlot), R(1), U8(9),
+ B(Wide), B(Jump), U16(-230),
+ B(Jump), U8(49),
+ B(Star), R(12),
+ B(LdaConstant), U8(11),
+ B(Star), R(11),
+ B(Ldar), R(closure),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(11), U8(3),
+ B(Star), R(10),
+ B(PushContext), R(2),
+ B(LdaContextSlot), R(1), U8(9),
+ B(Star), R(11),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(11),
+ B(JumpIfFalse), U8(7),
+ B(LdaSmi), U8(1),
+ B(StaContextSlot), R(1), U8(9),
+ B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(11),
+ B(CallRuntime), U16(Runtime::kReThrow), R(11), U8(1),
+ B(PopContext), R(2),
+ B(LdaSmi), U8(-1),
+ B(Star), R(7),
+ B(Jump), U8(8),
+ B(Star), R(8),
+ B(LdaSmi), U8(1),
+ B(Star), R(7),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(9),
+ B(LdaContextSlot), R(1), U8(9),
+ B(Star), R(10),
+ B(LdaZero),
+ B(TestEqualStrict), R(10),
+ B(JumpIfTrue), U8(10),
+ B(LdaContextSlot), R(1), U8(7),
+ B(Star), R(10),
+ B(LdaUndefined),
+ B(TestEqualStrict), R(10),
+ B(ToBooleanLogicalNot),
+ B(JumpIfFalseConstant), U8(16),
+ B(LdaContextSlot), R(1), U8(7),
+ B(Star), R(10),
+ B(LoadIC), R(10), U8(12), U8(13),
+ B(StaContextSlot), R(1), U8(11),
+ B(LdaContextSlot), R(1), U8(11),
+ B(Star), R(10),
+ B(LdaNull),
+ B(TestEqual), R(10),
+ B(JumpIfFalse), U8(4),
+ B(JumpConstant), U8(15),
+ B(LdaContextSlot), R(1), U8(9),
+ B(Star), R(10),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(10),
+ B(JumpIfFalse), U8(82),
+ B(LdaContextSlot), R(1), U8(11),
+ B(TypeOf),
+ B(Star), R(10),
+ B(LdaConstant), U8(13),
+ B(TestEqualStrict), R(10),
+ B(JumpIfFalse), U8(4),
+ B(Jump), U8(18),
+ B(Wide), B(LdaSmi), U16(129),
+ B(Star), R(10),
+ B(LdaConstant), U8(14),
+ B(Star), R(11),
+ B(CallRuntime), U16(Runtime::kNewTypeError), R(10), U8(2),
+ B(Throw),
+ B(Mov), R(context), R(10),
+ B(LdaContextSlot), R(1), U8(11),
+ B(Star), R(11),
+ B(LdaContextSlot), R(1), U8(7),
+ B(Star), R(12),
+ B(CallRuntime), U16(Runtime::k_Call), R(11), U8(2),
+ B(Jump), U8(30),
+ B(Star), R(12),
+ B(LdaConstant), U8(11),
+ B(Star), R(11),
+ B(Ldar), R(closure),
+ B(Star), R(13),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(11), U8(3),
+ B(Star), R(10),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(10),
+ B(PushContext), R(2),
+ B(PopContext), R(2),
+ B(Jump), U8(44),
+ B(LdaContextSlot), R(1), U8(11),
+ B(Star), R(10),
+ B(LdaContextSlot), R(1), U8(7),
+ B(Star), R(11),
+ B(CallRuntime), U16(Runtime::k_Call), R(10), U8(2),
+ B(StaContextSlot), R(1), U8(12),
+ B(LdaContextSlot), R(1), U8(12),
+ B(Star), R(10),
+ B(InvokeIntrinsic), U16(Runtime::k_IsJSReceiver), R(10), U8(1),
+ B(JumpIfToBooleanFalse), U8(4),
+ B(Jump), U8(12),
+ B(LdaContextSlot), R(1), U8(12),
+ B(Star), R(10),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(10), U8(1),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(9), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(7),
+ B(JumpIfTrue), U8(10),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(7),
+ B(JumpIfTrue), U8(18),
+ B(Jump), U8(30),
+ B(Ldar), R(8),
+ B(PopContext), R(1),
+ B(PopContext), R(1),
+ B(Star), R(5),
+ B(LdaSmi), U8(1),
+ B(Star), R(4),
+ B(Jump), U8(49),
+ B(Ldar), R(8),
+ B(PopContext), R(1),
+ B(PopContext), R(1),
+ B(Star), R(5),
+ B(LdaSmi), U8(2),
+ B(Star), R(4),
+ B(Jump), U8(35),
+ B(PopContext), R(1),
+ B(LdaUndefined),
+ B(Star), R(7),
+ B(LdaTrue),
+ B(Star), R(8),
+ B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(7), U8(2),
+ B(Star), R(5),
+ B(LdaSmi), U8(3),
+ B(Star), R(4),
+ B(Jump), U8(14),
+ B(LdaSmi), U8(-1),
+ B(Star), R(4),
+ B(Jump), U8(8),
+ B(Star), R(5),
+ B(LdaSmi), U8(4),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(6),
+ B(LdaContextSlot), R(context), U8(5),
+ B(Star), R(7),
+ B(CallRuntime), U16(Runtime::kGeneratorClose), R(7), U8(1),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(6), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(4),
+ B(JumpIfTrue), U8(28),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(4),
+ B(JumpIfTrue), U8(25),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(4),
+ B(JumpIfTrue), U8(22),
+ B(LdaSmi), U8(3),
+ B(TestEqualStrict), R(4),
+ B(JumpIfTrue), U8(19),
+ B(LdaSmi), U8(4),
+ B(TestEqualStrict), R(4),
+ B(JumpIfTrue), U8(16),
+ B(Jump), U8(17),
+ B(Ldar), R(5),
+ /* 44 S> */ B(Return),
+ B(Ldar), R(5),
+ /* 44 S> */ B(Return),
+ B(Ldar), R(5),
+ B(ReThrow),
+ B(Ldar), R(5),
+ /* 44 S> */ B(Return),
+ B(Ldar), R(5),
+ B(ReThrow),
+ B(LdaUndefined),
+ /* 44 S> */ B(Return),
+]
+constant pool: [
+ InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::SYMBOL_TYPE,
+ kInstanceTypeDontCare,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ kInstanceTypeDontCare,
+ kInstanceTypeDontCare,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ kInstanceTypeDontCare,
+ kInstanceTypeDontCare,
+ kInstanceTypeDontCare,
+]
+handlers: [
+ [44, 726, 732],
+ [156, 462, 468],
+ [159, 413, 415],
+ [570, 585, 587],
+]
+
diff --git a/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden b/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden
index 42a2c5b..89d31ee 100644
--- a/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden
+++ b/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden
@@ -18,13 +18,13 @@
parameter count: 1
bytecode array length: 14
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(BitwiseAnd), R(0),
- B(StaGlobalSloppy), U8(0), U8(3),
- B(Return),
+ /* 26 E> */ B(StackCheck),
+ /* 31 S> */ B(LdaGlobal), U8(0), U8(1),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ B(BitwiseAnd), R(0),
+ /* 45 E> */ B(StaGlobalSloppy), U8(0), U8(3),
+ /* 51 S> */ B(Return),
]
constant pool: [
"global",
@@ -42,13 +42,13 @@
parameter count: 1
bytecode array length: 14
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(Add), R(0),
- B(StaGlobalSloppy), U8(0), U8(3),
- B(Return),
+ /* 27 E> */ B(StackCheck),
+ /* 32 S> */ B(LdaGlobal), U8(0), U8(1),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ /* 51 E> */ B(StaGlobalSloppy), U8(0), U8(3),
+ /* 57 S> */ B(Return),
]
constant pool: [
"unallocated",
diff --git a/test/cctest/interpreter/bytecode_expectations/GlobalCountOperators.golden b/test/cctest/interpreter/bytecode_expectations/GlobalCountOperators.golden
index 7d64503..df64018 100644
--- a/test/cctest/interpreter/bytecode_expectations/GlobalCountOperators.golden
+++ b/test/cctest/interpreter/bytecode_expectations/GlobalCountOperators.golden
@@ -16,14 +16,13 @@
"
frame size: 0
parameter count: 1
-bytecode array length: 10
+bytecode array length: 9
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(ToNumber),
- B(Inc),
- B(StaGlobalSloppy), U8(0), U8(3),
- B(Return),
+ /* 26 E> */ B(StackCheck),
+ /* 31 S> */ B(LdaGlobal), U8(0), U8(1),
+ B(Inc),
+ /* 40 E> */ B(StaGlobalSloppy), U8(0), U8(3),
+ /* 48 S> */ B(Return),
]
constant pool: [
"global",
@@ -41,14 +40,14 @@
parameter count: 1
bytecode array length: 14
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(ToNumber),
- B(Star), R(0),
- B(Dec),
- B(StaGlobalSloppy), U8(0), U8(3),
- B(Ldar), R(0),
- B(Return),
+ /* 26 E> */ B(StackCheck),
+ /* 31 S> */ B(LdaGlobal), U8(0), U8(1),
+ B(ToNumber),
+ B(Star), R(0),
+ B(Dec),
+ /* 44 E> */ B(StaGlobalSloppy), U8(0), U8(3),
+ B(Ldar), R(0),
+ /* 48 S> */ B(Return),
]
constant pool: [
"global",
@@ -64,14 +63,13 @@
"
frame size: 0
parameter count: 1
-bytecode array length: 10
+bytecode array length: 9
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(ToNumber),
- B(Dec),
- B(StaGlobalStrict), U8(0), U8(3),
- B(Return),
+ /* 27 E> */ B(StackCheck),
+ /* 46 S> */ B(LdaGlobal), U8(0), U8(1),
+ B(Dec),
+ /* 55 E> */ B(StaGlobalStrict), U8(0), U8(3),
+ /* 68 S> */ B(Return),
]
constant pool: [
"unallocated",
@@ -89,14 +87,14 @@
parameter count: 1
bytecode array length: 14
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(ToNumber),
- B(Star), R(0),
- B(Inc),
- B(StaGlobalSloppy), U8(0), U8(3),
- B(Ldar), R(0),
- B(Return),
+ /* 27 E> */ B(StackCheck),
+ /* 32 S> */ B(LdaGlobal), U8(0), U8(1),
+ B(ToNumber),
+ B(Star), R(0),
+ B(Inc),
+ /* 50 E> */ B(StaGlobalSloppy), U8(0), U8(3),
+ B(Ldar), R(0),
+ /* 54 S> */ B(Return),
]
constant pool: [
"unallocated",
diff --git a/test/cctest/interpreter/bytecode_expectations/GlobalDelete.golden b/test/cctest/interpreter/bytecode_expectations/GlobalDelete.golden
index ffed12e..fc86582 100644
--- a/test/cctest/interpreter/bytecode_expectations/GlobalDelete.golden
+++ b/test/cctest/interpreter/bytecode_expectations/GlobalDelete.golden
@@ -20,12 +20,12 @@
parameter count: 1
bytecode array length: 11
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(DeletePropertySloppy), R(0),
- B(Return),
+ /* 32 E> */ B(StackCheck),
+ /* 39 S> */ B(LdaGlobal), U8(0), U8(1),
+ B(Star), R(0),
+ B(LdaConstant), U8(1),
+ B(DeletePropertySloppy), R(0),
+ /* 58 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -47,12 +47,12 @@
parameter count: 1
bytecode array length: 11
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(DeletePropertyStrict), R(0),
- B(Return),
+ /* 28 E> */ B(StackCheck),
+ /* 51 S> */ B(LdaGlobal), U8(0), U8(1),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ B(DeletePropertyStrict), R(0),
+ /* 71 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -72,14 +72,14 @@
parameter count: 1
bytecode array length: 16
bytecodes: [
- B(StackCheck),
- B(LdaContextSlot), R(context), U8(3),
- B(Star), R(0),
- B(LdaContextSlot), R(0), U8(2),
- B(Star), R(1),
- B(LdaConstant), U8(0),
- B(DeletePropertySloppy), R(1),
- B(Return),
+ /* 32 E> */ B(StackCheck),
+ /* 39 S> */ B(LdaContextSlot), R(context), U8(3),
+ B(Star), R(0),
+ B(LdaContextSlot), R(0), U8(2),
+ B(Star), R(1),
+ B(LdaConstant), U8(0),
+ B(DeletePropertySloppy), R(1),
+ /* 56 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -99,14 +99,14 @@
parameter count: 1
bytecode array length: 16
bytecodes: [
- B(StackCheck),
- B(LdaContextSlot), R(context), U8(3),
- B(Star), R(0),
- B(LdaContextSlot), R(0), U8(2),
- B(Star), R(1),
- B(LdaConstant), U8(0),
- B(DeletePropertySloppy), R(1),
- B(Return),
+ /* 18 E> */ B(StackCheck),
+ /* 25 S> */ B(LdaContextSlot), R(context), U8(3),
+ B(Star), R(0),
+ B(LdaContextSlot), R(0), U8(2),
+ B(Star), R(1),
+ B(LdaConstant), U8(0),
+ B(DeletePropertySloppy), R(1),
+ /* 42 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/HeapNumberConstants.golden b/test/cctest/interpreter/bytecode_expectations/HeapNumberConstants.golden
index 2ff2485..bcc4b67 100644
--- a/test/cctest/interpreter/bytecode_expectations/HeapNumberConstants.golden
+++ b/test/cctest/interpreter/bytecode_expectations/HeapNumberConstants.golden
@@ -15,9 +15,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaConstant), U8(0),
+ /* 46 S> */ B(Return),
]
constant pool: [
1.2,
@@ -33,11 +33,11 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(0),
+ /* 47 S> */ B(LdaConstant), U8(1),
+ /* 59 S> */ B(Return),
]
constant pool: [
1.2,
@@ -54,11 +54,11 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(0),
+ /* 48 S> */ B(LdaConstant), U8(1),
+ /* 61 S> */ B(Return),
]
constant pool: [
3.14,
@@ -331,523 +331,523 @@
parameter count: 1
bytecode array length: 1033
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(2),
- B(Star), R(0),
- B(LdaConstant), U8(3),
- B(Star), R(0),
- B(LdaConstant), U8(4),
- B(Star), R(0),
- B(LdaConstant), U8(5),
- B(Star), R(0),
- B(LdaConstant), U8(6),
- B(Star), R(0),
- B(LdaConstant), U8(7),
- B(Star), R(0),
- B(LdaConstant), U8(8),
- B(Star), R(0),
- B(LdaConstant), U8(9),
- B(Star), R(0),
- B(LdaConstant), U8(10),
- B(Star), R(0),
- B(LdaConstant), U8(11),
- B(Star), R(0),
- B(LdaConstant), U8(12),
- B(Star), R(0),
- B(LdaConstant), U8(13),
- B(Star), R(0),
- B(LdaConstant), U8(14),
- B(Star), R(0),
- B(LdaConstant), U8(15),
- B(Star), R(0),
- B(LdaConstant), U8(16),
- B(Star), R(0),
- B(LdaConstant), U8(17),
- B(Star), R(0),
- B(LdaConstant), U8(18),
- B(Star), R(0),
- B(LdaConstant), U8(19),
- B(Star), R(0),
- B(LdaConstant), U8(20),
- B(Star), R(0),
- B(LdaConstant), U8(21),
- B(Star), R(0),
- B(LdaConstant), U8(22),
- B(Star), R(0),
- B(LdaConstant), U8(23),
- B(Star), R(0),
- B(LdaConstant), U8(24),
- B(Star), R(0),
- B(LdaConstant), U8(25),
- B(Star), R(0),
- B(LdaConstant), U8(26),
- B(Star), R(0),
- B(LdaConstant), U8(27),
- B(Star), R(0),
- B(LdaConstant), U8(28),
- B(Star), R(0),
- B(LdaConstant), U8(29),
- B(Star), R(0),
- B(LdaConstant), U8(30),
- B(Star), R(0),
- B(LdaConstant), U8(31),
- B(Star), R(0),
- B(LdaConstant), U8(32),
- B(Star), R(0),
- B(LdaConstant), U8(33),
- B(Star), R(0),
- B(LdaConstant), U8(34),
- B(Star), R(0),
- B(LdaConstant), U8(35),
- B(Star), R(0),
- B(LdaConstant), U8(36),
- B(Star), R(0),
- B(LdaConstant), U8(37),
- B(Star), R(0),
- B(LdaConstant), U8(38),
- B(Star), R(0),
- B(LdaConstant), U8(39),
- B(Star), R(0),
- B(LdaConstant), U8(40),
- B(Star), R(0),
- B(LdaConstant), U8(41),
- B(Star), R(0),
- B(LdaConstant), U8(42),
- B(Star), R(0),
- B(LdaConstant), U8(43),
- B(Star), R(0),
- B(LdaConstant), U8(44),
- B(Star), R(0),
- B(LdaConstant), U8(45),
- B(Star), R(0),
- B(LdaConstant), U8(46),
- B(Star), R(0),
- B(LdaConstant), U8(47),
- B(Star), R(0),
- B(LdaConstant), U8(48),
- B(Star), R(0),
- B(LdaConstant), U8(49),
- B(Star), R(0),
- B(LdaConstant), U8(50),
- B(Star), R(0),
- B(LdaConstant), U8(51),
- B(Star), R(0),
- B(LdaConstant), U8(52),
- B(Star), R(0),
- B(LdaConstant), U8(53),
- B(Star), R(0),
- B(LdaConstant), U8(54),
- B(Star), R(0),
- B(LdaConstant), U8(55),
- B(Star), R(0),
- B(LdaConstant), U8(56),
- B(Star), R(0),
- B(LdaConstant), U8(57),
- B(Star), R(0),
- B(LdaConstant), U8(58),
- B(Star), R(0),
- B(LdaConstant), U8(59),
- B(Star), R(0),
- B(LdaConstant), U8(60),
- B(Star), R(0),
- B(LdaConstant), U8(61),
- B(Star), R(0),
- B(LdaConstant), U8(62),
- B(Star), R(0),
- B(LdaConstant), U8(63),
- B(Star), R(0),
- B(LdaConstant), U8(64),
- B(Star), R(0),
- B(LdaConstant), U8(65),
- B(Star), R(0),
- B(LdaConstant), U8(66),
- B(Star), R(0),
- B(LdaConstant), U8(67),
- B(Star), R(0),
- B(LdaConstant), U8(68),
- B(Star), R(0),
- B(LdaConstant), U8(69),
- B(Star), R(0),
- B(LdaConstant), U8(70),
- B(Star), R(0),
- B(LdaConstant), U8(71),
- B(Star), R(0),
- B(LdaConstant), U8(72),
- B(Star), R(0),
- B(LdaConstant), U8(73),
- B(Star), R(0),
- B(LdaConstant), U8(74),
- B(Star), R(0),
- B(LdaConstant), U8(75),
- B(Star), R(0),
- B(LdaConstant), U8(76),
- B(Star), R(0),
- B(LdaConstant), U8(77),
- B(Star), R(0),
- B(LdaConstant), U8(78),
- B(Star), R(0),
- B(LdaConstant), U8(79),
- B(Star), R(0),
- B(LdaConstant), U8(80),
- B(Star), R(0),
- B(LdaConstant), U8(81),
- B(Star), R(0),
- B(LdaConstant), U8(82),
- B(Star), R(0),
- B(LdaConstant), U8(83),
- B(Star), R(0),
- B(LdaConstant), U8(84),
- B(Star), R(0),
- B(LdaConstant), U8(85),
- B(Star), R(0),
- B(LdaConstant), U8(86),
- B(Star), R(0),
- B(LdaConstant), U8(87),
- B(Star), R(0),
- B(LdaConstant), U8(88),
- B(Star), R(0),
- B(LdaConstant), U8(89),
- B(Star), R(0),
- B(LdaConstant), U8(90),
- B(Star), R(0),
- B(LdaConstant), U8(91),
- B(Star), R(0),
- B(LdaConstant), U8(92),
- B(Star), R(0),
- B(LdaConstant), U8(93),
- B(Star), R(0),
- B(LdaConstant), U8(94),
- B(Star), R(0),
- B(LdaConstant), U8(95),
- B(Star), R(0),
- B(LdaConstant), U8(96),
- B(Star), R(0),
- B(LdaConstant), U8(97),
- B(Star), R(0),
- B(LdaConstant), U8(98),
- B(Star), R(0),
- B(LdaConstant), U8(99),
- B(Star), R(0),
- B(LdaConstant), U8(100),
- B(Star), R(0),
- B(LdaConstant), U8(101),
- B(Star), R(0),
- B(LdaConstant), U8(102),
- B(Star), R(0),
- B(LdaConstant), U8(103),
- B(Star), R(0),
- B(LdaConstant), U8(104),
- B(Star), R(0),
- B(LdaConstant), U8(105),
- B(Star), R(0),
- B(LdaConstant), U8(106),
- B(Star), R(0),
- B(LdaConstant), U8(107),
- B(Star), R(0),
- B(LdaConstant), U8(108),
- B(Star), R(0),
- B(LdaConstant), U8(109),
- B(Star), R(0),
- B(LdaConstant), U8(110),
- B(Star), R(0),
- B(LdaConstant), U8(111),
- B(Star), R(0),
- B(LdaConstant), U8(112),
- B(Star), R(0),
- B(LdaConstant), U8(113),
- B(Star), R(0),
- B(LdaConstant), U8(114),
- B(Star), R(0),
- B(LdaConstant), U8(115),
- B(Star), R(0),
- B(LdaConstant), U8(116),
- B(Star), R(0),
- B(LdaConstant), U8(117),
- B(Star), R(0),
- B(LdaConstant), U8(118),
- B(Star), R(0),
- B(LdaConstant), U8(119),
- B(Star), R(0),
- B(LdaConstant), U8(120),
- B(Star), R(0),
- B(LdaConstant), U8(121),
- B(Star), R(0),
- B(LdaConstant), U8(122),
- B(Star), R(0),
- B(LdaConstant), U8(123),
- B(Star), R(0),
- B(LdaConstant), U8(124),
- B(Star), R(0),
- B(LdaConstant), U8(125),
- B(Star), R(0),
- B(LdaConstant), U8(126),
- B(Star), R(0),
- B(LdaConstant), U8(127),
- B(Star), R(0),
- B(LdaConstant), U8(128),
- B(Star), R(0),
- B(LdaConstant), U8(129),
- B(Star), R(0),
- B(LdaConstant), U8(130),
- B(Star), R(0),
- B(LdaConstant), U8(131),
- B(Star), R(0),
- B(LdaConstant), U8(132),
- B(Star), R(0),
- B(LdaConstant), U8(133),
- B(Star), R(0),
- B(LdaConstant), U8(134),
- B(Star), R(0),
- B(LdaConstant), U8(135),
- B(Star), R(0),
- B(LdaConstant), U8(136),
- B(Star), R(0),
- B(LdaConstant), U8(137),
- B(Star), R(0),
- B(LdaConstant), U8(138),
- B(Star), R(0),
- B(LdaConstant), U8(139),
- B(Star), R(0),
- B(LdaConstant), U8(140),
- B(Star), R(0),
- B(LdaConstant), U8(141),
- B(Star), R(0),
- B(LdaConstant), U8(142),
- B(Star), R(0),
- B(LdaConstant), U8(143),
- B(Star), R(0),
- B(LdaConstant), U8(144),
- B(Star), R(0),
- B(LdaConstant), U8(145),
- B(Star), R(0),
- B(LdaConstant), U8(146),
- B(Star), R(0),
- B(LdaConstant), U8(147),
- B(Star), R(0),
- B(LdaConstant), U8(148),
- B(Star), R(0),
- B(LdaConstant), U8(149),
- B(Star), R(0),
- B(LdaConstant), U8(150),
- B(Star), R(0),
- B(LdaConstant), U8(151),
- B(Star), R(0),
- B(LdaConstant), U8(152),
- B(Star), R(0),
- B(LdaConstant), U8(153),
- B(Star), R(0),
- B(LdaConstant), U8(154),
- B(Star), R(0),
- B(LdaConstant), U8(155),
- B(Star), R(0),
- B(LdaConstant), U8(156),
- B(Star), R(0),
- B(LdaConstant), U8(157),
- B(Star), R(0),
- B(LdaConstant), U8(158),
- B(Star), R(0),
- B(LdaConstant), U8(159),
- B(Star), R(0),
- B(LdaConstant), U8(160),
- B(Star), R(0),
- B(LdaConstant), U8(161),
- B(Star), R(0),
- B(LdaConstant), U8(162),
- B(Star), R(0),
- B(LdaConstant), U8(163),
- B(Star), R(0),
- B(LdaConstant), U8(164),
- B(Star), R(0),
- B(LdaConstant), U8(165),
- B(Star), R(0),
- B(LdaConstant), U8(166),
- B(Star), R(0),
- B(LdaConstant), U8(167),
- B(Star), R(0),
- B(LdaConstant), U8(168),
- B(Star), R(0),
- B(LdaConstant), U8(169),
- B(Star), R(0),
- B(LdaConstant), U8(170),
- B(Star), R(0),
- B(LdaConstant), U8(171),
- B(Star), R(0),
- B(LdaConstant), U8(172),
- B(Star), R(0),
- B(LdaConstant), U8(173),
- B(Star), R(0),
- B(LdaConstant), U8(174),
- B(Star), R(0),
- B(LdaConstant), U8(175),
- B(Star), R(0),
- B(LdaConstant), U8(176),
- B(Star), R(0),
- B(LdaConstant), U8(177),
- B(Star), R(0),
- B(LdaConstant), U8(178),
- B(Star), R(0),
- B(LdaConstant), U8(179),
- B(Star), R(0),
- B(LdaConstant), U8(180),
- B(Star), R(0),
- B(LdaConstant), U8(181),
- B(Star), R(0),
- B(LdaConstant), U8(182),
- B(Star), R(0),
- B(LdaConstant), U8(183),
- B(Star), R(0),
- B(LdaConstant), U8(184),
- B(Star), R(0),
- B(LdaConstant), U8(185),
- B(Star), R(0),
- B(LdaConstant), U8(186),
- B(Star), R(0),
- B(LdaConstant), U8(187),
- B(Star), R(0),
- B(LdaConstant), U8(188),
- B(Star), R(0),
- B(LdaConstant), U8(189),
- B(Star), R(0),
- B(LdaConstant), U8(190),
- B(Star), R(0),
- B(LdaConstant), U8(191),
- B(Star), R(0),
- B(LdaConstant), U8(192),
- B(Star), R(0),
- B(LdaConstant), U8(193),
- B(Star), R(0),
- B(LdaConstant), U8(194),
- B(Star), R(0),
- B(LdaConstant), U8(195),
- B(Star), R(0),
- B(LdaConstant), U8(196),
- B(Star), R(0),
- B(LdaConstant), U8(197),
- B(Star), R(0),
- B(LdaConstant), U8(198),
- B(Star), R(0),
- B(LdaConstant), U8(199),
- B(Star), R(0),
- B(LdaConstant), U8(200),
- B(Star), R(0),
- B(LdaConstant), U8(201),
- B(Star), R(0),
- B(LdaConstant), U8(202),
- B(Star), R(0),
- B(LdaConstant), U8(203),
- B(Star), R(0),
- B(LdaConstant), U8(204),
- B(Star), R(0),
- B(LdaConstant), U8(205),
- B(Star), R(0),
- B(LdaConstant), U8(206),
- B(Star), R(0),
- B(LdaConstant), U8(207),
- B(Star), R(0),
- B(LdaConstant), U8(208),
- B(Star), R(0),
- B(LdaConstant), U8(209),
- B(Star), R(0),
- B(LdaConstant), U8(210),
- B(Star), R(0),
- B(LdaConstant), U8(211),
- B(Star), R(0),
- B(LdaConstant), U8(212),
- B(Star), R(0),
- B(LdaConstant), U8(213),
- B(Star), R(0),
- B(LdaConstant), U8(214),
- B(Star), R(0),
- B(LdaConstant), U8(215),
- B(Star), R(0),
- B(LdaConstant), U8(216),
- B(Star), R(0),
- B(LdaConstant), U8(217),
- B(Star), R(0),
- B(LdaConstant), U8(218),
- B(Star), R(0),
- B(LdaConstant), U8(219),
- B(Star), R(0),
- B(LdaConstant), U8(220),
- B(Star), R(0),
- B(LdaConstant), U8(221),
- B(Star), R(0),
- B(LdaConstant), U8(222),
- B(Star), R(0),
- B(LdaConstant), U8(223),
- B(Star), R(0),
- B(LdaConstant), U8(224),
- B(Star), R(0),
- B(LdaConstant), U8(225),
- B(Star), R(0),
- B(LdaConstant), U8(226),
- B(Star), R(0),
- B(LdaConstant), U8(227),
- B(Star), R(0),
- B(LdaConstant), U8(228),
- B(Star), R(0),
- B(LdaConstant), U8(229),
- B(Star), R(0),
- B(LdaConstant), U8(230),
- B(Star), R(0),
- B(LdaConstant), U8(231),
- B(Star), R(0),
- B(LdaConstant), U8(232),
- B(Star), R(0),
- B(LdaConstant), U8(233),
- B(Star), R(0),
- B(LdaConstant), U8(234),
- B(Star), R(0),
- B(LdaConstant), U8(235),
- B(Star), R(0),
- B(LdaConstant), U8(236),
- B(Star), R(0),
- B(LdaConstant), U8(237),
- B(Star), R(0),
- B(LdaConstant), U8(238),
- B(Star), R(0),
- B(LdaConstant), U8(239),
- B(Star), R(0),
- B(LdaConstant), U8(240),
- B(Star), R(0),
- B(LdaConstant), U8(241),
- B(Star), R(0),
- B(LdaConstant), U8(242),
- B(Star), R(0),
- B(LdaConstant), U8(243),
- B(Star), R(0),
- B(LdaConstant), U8(244),
- B(Star), R(0),
- B(LdaConstant), U8(245),
- B(Star), R(0),
- B(LdaConstant), U8(246),
- B(Star), R(0),
- B(LdaConstant), U8(247),
- B(Star), R(0),
- B(LdaConstant), U8(248),
- B(Star), R(0),
- B(LdaConstant), U8(249),
- B(Star), R(0),
- B(LdaConstant), U8(250),
- B(Star), R(0),
- B(LdaConstant), U8(251),
- B(Star), R(0),
- B(LdaConstant), U8(252),
- B(Star), R(0),
- B(LdaConstant), U8(253),
- B(Star), R(0),
- B(LdaConstant), U8(254),
- B(Star), R(0),
- B(LdaConstant), U8(255),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(256),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 41 S> */ B(LdaConstant), U8(0),
+ /* 43 E> */ B(Star), R(0),
+ /* 52 S> */ B(LdaConstant), U8(1),
+ /* 54 E> */ B(Star), R(0),
+ /* 63 S> */ B(LdaConstant), U8(2),
+ /* 65 E> */ B(Star), R(0),
+ /* 74 S> */ B(LdaConstant), U8(3),
+ /* 76 E> */ B(Star), R(0),
+ /* 85 S> */ B(LdaConstant), U8(4),
+ /* 87 E> */ B(Star), R(0),
+ /* 96 S> */ B(LdaConstant), U8(5),
+ /* 98 E> */ B(Star), R(0),
+ /* 107 S> */ B(LdaConstant), U8(6),
+ /* 109 E> */ B(Star), R(0),
+ /* 118 S> */ B(LdaConstant), U8(7),
+ /* 120 E> */ B(Star), R(0),
+ /* 129 S> */ B(LdaConstant), U8(8),
+ /* 131 E> */ B(Star), R(0),
+ /* 140 S> */ B(LdaConstant), U8(9),
+ /* 142 E> */ B(Star), R(0),
+ /* 151 S> */ B(LdaConstant), U8(10),
+ /* 153 E> */ B(Star), R(0),
+ /* 162 S> */ B(LdaConstant), U8(11),
+ /* 164 E> */ B(Star), R(0),
+ /* 173 S> */ B(LdaConstant), U8(12),
+ /* 175 E> */ B(Star), R(0),
+ /* 184 S> */ B(LdaConstant), U8(13),
+ /* 186 E> */ B(Star), R(0),
+ /* 195 S> */ B(LdaConstant), U8(14),
+ /* 197 E> */ B(Star), R(0),
+ /* 206 S> */ B(LdaConstant), U8(15),
+ /* 208 E> */ B(Star), R(0),
+ /* 217 S> */ B(LdaConstant), U8(16),
+ /* 219 E> */ B(Star), R(0),
+ /* 228 S> */ B(LdaConstant), U8(17),
+ /* 230 E> */ B(Star), R(0),
+ /* 239 S> */ B(LdaConstant), U8(18),
+ /* 241 E> */ B(Star), R(0),
+ /* 250 S> */ B(LdaConstant), U8(19),
+ /* 252 E> */ B(Star), R(0),
+ /* 261 S> */ B(LdaConstant), U8(20),
+ /* 263 E> */ B(Star), R(0),
+ /* 272 S> */ B(LdaConstant), U8(21),
+ /* 274 E> */ B(Star), R(0),
+ /* 283 S> */ B(LdaConstant), U8(22),
+ /* 285 E> */ B(Star), R(0),
+ /* 294 S> */ B(LdaConstant), U8(23),
+ /* 296 E> */ B(Star), R(0),
+ /* 305 S> */ B(LdaConstant), U8(24),
+ /* 307 E> */ B(Star), R(0),
+ /* 316 S> */ B(LdaConstant), U8(25),
+ /* 318 E> */ B(Star), R(0),
+ /* 327 S> */ B(LdaConstant), U8(26),
+ /* 329 E> */ B(Star), R(0),
+ /* 338 S> */ B(LdaConstant), U8(27),
+ /* 340 E> */ B(Star), R(0),
+ /* 349 S> */ B(LdaConstant), U8(28),
+ /* 351 E> */ B(Star), R(0),
+ /* 360 S> */ B(LdaConstant), U8(29),
+ /* 362 E> */ B(Star), R(0),
+ /* 371 S> */ B(LdaConstant), U8(30),
+ /* 373 E> */ B(Star), R(0),
+ /* 382 S> */ B(LdaConstant), U8(31),
+ /* 384 E> */ B(Star), R(0),
+ /* 393 S> */ B(LdaConstant), U8(32),
+ /* 395 E> */ B(Star), R(0),
+ /* 404 S> */ B(LdaConstant), U8(33),
+ /* 406 E> */ B(Star), R(0),
+ /* 415 S> */ B(LdaConstant), U8(34),
+ /* 417 E> */ B(Star), R(0),
+ /* 426 S> */ B(LdaConstant), U8(35),
+ /* 428 E> */ B(Star), R(0),
+ /* 437 S> */ B(LdaConstant), U8(36),
+ /* 439 E> */ B(Star), R(0),
+ /* 448 S> */ B(LdaConstant), U8(37),
+ /* 450 E> */ B(Star), R(0),
+ /* 459 S> */ B(LdaConstant), U8(38),
+ /* 461 E> */ B(Star), R(0),
+ /* 470 S> */ B(LdaConstant), U8(39),
+ /* 472 E> */ B(Star), R(0),
+ /* 481 S> */ B(LdaConstant), U8(40),
+ /* 483 E> */ B(Star), R(0),
+ /* 492 S> */ B(LdaConstant), U8(41),
+ /* 494 E> */ B(Star), R(0),
+ /* 503 S> */ B(LdaConstant), U8(42),
+ /* 505 E> */ B(Star), R(0),
+ /* 514 S> */ B(LdaConstant), U8(43),
+ /* 516 E> */ B(Star), R(0),
+ /* 525 S> */ B(LdaConstant), U8(44),
+ /* 527 E> */ B(Star), R(0),
+ /* 536 S> */ B(LdaConstant), U8(45),
+ /* 538 E> */ B(Star), R(0),
+ /* 547 S> */ B(LdaConstant), U8(46),
+ /* 549 E> */ B(Star), R(0),
+ /* 558 S> */ B(LdaConstant), U8(47),
+ /* 560 E> */ B(Star), R(0),
+ /* 569 S> */ B(LdaConstant), U8(48),
+ /* 571 E> */ B(Star), R(0),
+ /* 580 S> */ B(LdaConstant), U8(49),
+ /* 582 E> */ B(Star), R(0),
+ /* 591 S> */ B(LdaConstant), U8(50),
+ /* 593 E> */ B(Star), R(0),
+ /* 602 S> */ B(LdaConstant), U8(51),
+ /* 604 E> */ B(Star), R(0),
+ /* 613 S> */ B(LdaConstant), U8(52),
+ /* 615 E> */ B(Star), R(0),
+ /* 624 S> */ B(LdaConstant), U8(53),
+ /* 626 E> */ B(Star), R(0),
+ /* 635 S> */ B(LdaConstant), U8(54),
+ /* 637 E> */ B(Star), R(0),
+ /* 646 S> */ B(LdaConstant), U8(55),
+ /* 648 E> */ B(Star), R(0),
+ /* 657 S> */ B(LdaConstant), U8(56),
+ /* 659 E> */ B(Star), R(0),
+ /* 668 S> */ B(LdaConstant), U8(57),
+ /* 670 E> */ B(Star), R(0),
+ /* 679 S> */ B(LdaConstant), U8(58),
+ /* 681 E> */ B(Star), R(0),
+ /* 690 S> */ B(LdaConstant), U8(59),
+ /* 692 E> */ B(Star), R(0),
+ /* 701 S> */ B(LdaConstant), U8(60),
+ /* 703 E> */ B(Star), R(0),
+ /* 712 S> */ B(LdaConstant), U8(61),
+ /* 714 E> */ B(Star), R(0),
+ /* 723 S> */ B(LdaConstant), U8(62),
+ /* 725 E> */ B(Star), R(0),
+ /* 734 S> */ B(LdaConstant), U8(63),
+ /* 736 E> */ B(Star), R(0),
+ /* 745 S> */ B(LdaConstant), U8(64),
+ /* 747 E> */ B(Star), R(0),
+ /* 756 S> */ B(LdaConstant), U8(65),
+ /* 758 E> */ B(Star), R(0),
+ /* 767 S> */ B(LdaConstant), U8(66),
+ /* 769 E> */ B(Star), R(0),
+ /* 778 S> */ B(LdaConstant), U8(67),
+ /* 780 E> */ B(Star), R(0),
+ /* 789 S> */ B(LdaConstant), U8(68),
+ /* 791 E> */ B(Star), R(0),
+ /* 800 S> */ B(LdaConstant), U8(69),
+ /* 802 E> */ B(Star), R(0),
+ /* 811 S> */ B(LdaConstant), U8(70),
+ /* 813 E> */ B(Star), R(0),
+ /* 822 S> */ B(LdaConstant), U8(71),
+ /* 824 E> */ B(Star), R(0),
+ /* 833 S> */ B(LdaConstant), U8(72),
+ /* 835 E> */ B(Star), R(0),
+ /* 844 S> */ B(LdaConstant), U8(73),
+ /* 846 E> */ B(Star), R(0),
+ /* 855 S> */ B(LdaConstant), U8(74),
+ /* 857 E> */ B(Star), R(0),
+ /* 866 S> */ B(LdaConstant), U8(75),
+ /* 868 E> */ B(Star), R(0),
+ /* 877 S> */ B(LdaConstant), U8(76),
+ /* 879 E> */ B(Star), R(0),
+ /* 888 S> */ B(LdaConstant), U8(77),
+ /* 890 E> */ B(Star), R(0),
+ /* 899 S> */ B(LdaConstant), U8(78),
+ /* 901 E> */ B(Star), R(0),
+ /* 910 S> */ B(LdaConstant), U8(79),
+ /* 912 E> */ B(Star), R(0),
+ /* 921 S> */ B(LdaConstant), U8(80),
+ /* 923 E> */ B(Star), R(0),
+ /* 932 S> */ B(LdaConstant), U8(81),
+ /* 934 E> */ B(Star), R(0),
+ /* 943 S> */ B(LdaConstant), U8(82),
+ /* 945 E> */ B(Star), R(0),
+ /* 954 S> */ B(LdaConstant), U8(83),
+ /* 956 E> */ B(Star), R(0),
+ /* 965 S> */ B(LdaConstant), U8(84),
+ /* 967 E> */ B(Star), R(0),
+ /* 976 S> */ B(LdaConstant), U8(85),
+ /* 978 E> */ B(Star), R(0),
+ /* 987 S> */ B(LdaConstant), U8(86),
+ /* 989 E> */ B(Star), R(0),
+ /* 998 S> */ B(LdaConstant), U8(87),
+ /* 1000 E> */ B(Star), R(0),
+ /* 1009 S> */ B(LdaConstant), U8(88),
+ /* 1011 E> */ B(Star), R(0),
+ /* 1020 S> */ B(LdaConstant), U8(89),
+ /* 1022 E> */ B(Star), R(0),
+ /* 1031 S> */ B(LdaConstant), U8(90),
+ /* 1033 E> */ B(Star), R(0),
+ /* 1042 S> */ B(LdaConstant), U8(91),
+ /* 1044 E> */ B(Star), R(0),
+ /* 1053 S> */ B(LdaConstant), U8(92),
+ /* 1055 E> */ B(Star), R(0),
+ /* 1064 S> */ B(LdaConstant), U8(93),
+ /* 1066 E> */ B(Star), R(0),
+ /* 1075 S> */ B(LdaConstant), U8(94),
+ /* 1077 E> */ B(Star), R(0),
+ /* 1086 S> */ B(LdaConstant), U8(95),
+ /* 1088 E> */ B(Star), R(0),
+ /* 1097 S> */ B(LdaConstant), U8(96),
+ /* 1099 E> */ B(Star), R(0),
+ /* 1108 S> */ B(LdaConstant), U8(97),
+ /* 1110 E> */ B(Star), R(0),
+ /* 1119 S> */ B(LdaConstant), U8(98),
+ /* 1121 E> */ B(Star), R(0),
+ /* 1130 S> */ B(LdaConstant), U8(99),
+ /* 1132 E> */ B(Star), R(0),
+ /* 1141 S> */ B(LdaConstant), U8(100),
+ /* 1143 E> */ B(Star), R(0),
+ /* 1152 S> */ B(LdaConstant), U8(101),
+ /* 1154 E> */ B(Star), R(0),
+ /* 1163 S> */ B(LdaConstant), U8(102),
+ /* 1165 E> */ B(Star), R(0),
+ /* 1174 S> */ B(LdaConstant), U8(103),
+ /* 1176 E> */ B(Star), R(0),
+ /* 1185 S> */ B(LdaConstant), U8(104),
+ /* 1187 E> */ B(Star), R(0),
+ /* 1196 S> */ B(LdaConstant), U8(105),
+ /* 1198 E> */ B(Star), R(0),
+ /* 1207 S> */ B(LdaConstant), U8(106),
+ /* 1209 E> */ B(Star), R(0),
+ /* 1218 S> */ B(LdaConstant), U8(107),
+ /* 1220 E> */ B(Star), R(0),
+ /* 1229 S> */ B(LdaConstant), U8(108),
+ /* 1231 E> */ B(Star), R(0),
+ /* 1240 S> */ B(LdaConstant), U8(109),
+ /* 1242 E> */ B(Star), R(0),
+ /* 1251 S> */ B(LdaConstant), U8(110),
+ /* 1253 E> */ B(Star), R(0),
+ /* 1262 S> */ B(LdaConstant), U8(111),
+ /* 1264 E> */ B(Star), R(0),
+ /* 1273 S> */ B(LdaConstant), U8(112),
+ /* 1275 E> */ B(Star), R(0),
+ /* 1284 S> */ B(LdaConstant), U8(113),
+ /* 1286 E> */ B(Star), R(0),
+ /* 1295 S> */ B(LdaConstant), U8(114),
+ /* 1297 E> */ B(Star), R(0),
+ /* 1306 S> */ B(LdaConstant), U8(115),
+ /* 1308 E> */ B(Star), R(0),
+ /* 1317 S> */ B(LdaConstant), U8(116),
+ /* 1319 E> */ B(Star), R(0),
+ /* 1328 S> */ B(LdaConstant), U8(117),
+ /* 1330 E> */ B(Star), R(0),
+ /* 1339 S> */ B(LdaConstant), U8(118),
+ /* 1341 E> */ B(Star), R(0),
+ /* 1350 S> */ B(LdaConstant), U8(119),
+ /* 1352 E> */ B(Star), R(0),
+ /* 1361 S> */ B(LdaConstant), U8(120),
+ /* 1363 E> */ B(Star), R(0),
+ /* 1372 S> */ B(LdaConstant), U8(121),
+ /* 1374 E> */ B(Star), R(0),
+ /* 1383 S> */ B(LdaConstant), U8(122),
+ /* 1385 E> */ B(Star), R(0),
+ /* 1394 S> */ B(LdaConstant), U8(123),
+ /* 1396 E> */ B(Star), R(0),
+ /* 1405 S> */ B(LdaConstant), U8(124),
+ /* 1407 E> */ B(Star), R(0),
+ /* 1416 S> */ B(LdaConstant), U8(125),
+ /* 1418 E> */ B(Star), R(0),
+ /* 1427 S> */ B(LdaConstant), U8(126),
+ /* 1429 E> */ B(Star), R(0),
+ /* 1438 S> */ B(LdaConstant), U8(127),
+ /* 1440 E> */ B(Star), R(0),
+ /* 1449 S> */ B(LdaConstant), U8(128),
+ /* 1451 E> */ B(Star), R(0),
+ /* 1460 S> */ B(LdaConstant), U8(129),
+ /* 1462 E> */ B(Star), R(0),
+ /* 1471 S> */ B(LdaConstant), U8(130),
+ /* 1473 E> */ B(Star), R(0),
+ /* 1482 S> */ B(LdaConstant), U8(131),
+ /* 1484 E> */ B(Star), R(0),
+ /* 1493 S> */ B(LdaConstant), U8(132),
+ /* 1495 E> */ B(Star), R(0),
+ /* 1504 S> */ B(LdaConstant), U8(133),
+ /* 1506 E> */ B(Star), R(0),
+ /* 1515 S> */ B(LdaConstant), U8(134),
+ /* 1517 E> */ B(Star), R(0),
+ /* 1526 S> */ B(LdaConstant), U8(135),
+ /* 1528 E> */ B(Star), R(0),
+ /* 1537 S> */ B(LdaConstant), U8(136),
+ /* 1539 E> */ B(Star), R(0),
+ /* 1548 S> */ B(LdaConstant), U8(137),
+ /* 1550 E> */ B(Star), R(0),
+ /* 1559 S> */ B(LdaConstant), U8(138),
+ /* 1561 E> */ B(Star), R(0),
+ /* 1570 S> */ B(LdaConstant), U8(139),
+ /* 1572 E> */ B(Star), R(0),
+ /* 1581 S> */ B(LdaConstant), U8(140),
+ /* 1583 E> */ B(Star), R(0),
+ /* 1592 S> */ B(LdaConstant), U8(141),
+ /* 1594 E> */ B(Star), R(0),
+ /* 1603 S> */ B(LdaConstant), U8(142),
+ /* 1605 E> */ B(Star), R(0),
+ /* 1614 S> */ B(LdaConstant), U8(143),
+ /* 1616 E> */ B(Star), R(0),
+ /* 1625 S> */ B(LdaConstant), U8(144),
+ /* 1627 E> */ B(Star), R(0),
+ /* 1636 S> */ B(LdaConstant), U8(145),
+ /* 1638 E> */ B(Star), R(0),
+ /* 1647 S> */ B(LdaConstant), U8(146),
+ /* 1649 E> */ B(Star), R(0),
+ /* 1658 S> */ B(LdaConstant), U8(147),
+ /* 1660 E> */ B(Star), R(0),
+ /* 1669 S> */ B(LdaConstant), U8(148),
+ /* 1671 E> */ B(Star), R(0),
+ /* 1680 S> */ B(LdaConstant), U8(149),
+ /* 1682 E> */ B(Star), R(0),
+ /* 1691 S> */ B(LdaConstant), U8(150),
+ /* 1693 E> */ B(Star), R(0),
+ /* 1702 S> */ B(LdaConstant), U8(151),
+ /* 1704 E> */ B(Star), R(0),
+ /* 1713 S> */ B(LdaConstant), U8(152),
+ /* 1715 E> */ B(Star), R(0),
+ /* 1724 S> */ B(LdaConstant), U8(153),
+ /* 1726 E> */ B(Star), R(0),
+ /* 1735 S> */ B(LdaConstant), U8(154),
+ /* 1737 E> */ B(Star), R(0),
+ /* 1746 S> */ B(LdaConstant), U8(155),
+ /* 1748 E> */ B(Star), R(0),
+ /* 1757 S> */ B(LdaConstant), U8(156),
+ /* 1759 E> */ B(Star), R(0),
+ /* 1768 S> */ B(LdaConstant), U8(157),
+ /* 1770 E> */ B(Star), R(0),
+ /* 1779 S> */ B(LdaConstant), U8(158),
+ /* 1781 E> */ B(Star), R(0),
+ /* 1790 S> */ B(LdaConstant), U8(159),
+ /* 1792 E> */ B(Star), R(0),
+ /* 1801 S> */ B(LdaConstant), U8(160),
+ /* 1803 E> */ B(Star), R(0),
+ /* 1812 S> */ B(LdaConstant), U8(161),
+ /* 1814 E> */ B(Star), R(0),
+ /* 1823 S> */ B(LdaConstant), U8(162),
+ /* 1825 E> */ B(Star), R(0),
+ /* 1834 S> */ B(LdaConstant), U8(163),
+ /* 1836 E> */ B(Star), R(0),
+ /* 1845 S> */ B(LdaConstant), U8(164),
+ /* 1847 E> */ B(Star), R(0),
+ /* 1856 S> */ B(LdaConstant), U8(165),
+ /* 1858 E> */ B(Star), R(0),
+ /* 1867 S> */ B(LdaConstant), U8(166),
+ /* 1869 E> */ B(Star), R(0),
+ /* 1878 S> */ B(LdaConstant), U8(167),
+ /* 1880 E> */ B(Star), R(0),
+ /* 1889 S> */ B(LdaConstant), U8(168),
+ /* 1891 E> */ B(Star), R(0),
+ /* 1900 S> */ B(LdaConstant), U8(169),
+ /* 1902 E> */ B(Star), R(0),
+ /* 1911 S> */ B(LdaConstant), U8(170),
+ /* 1913 E> */ B(Star), R(0),
+ /* 1922 S> */ B(LdaConstant), U8(171),
+ /* 1924 E> */ B(Star), R(0),
+ /* 1933 S> */ B(LdaConstant), U8(172),
+ /* 1935 E> */ B(Star), R(0),
+ /* 1944 S> */ B(LdaConstant), U8(173),
+ /* 1946 E> */ B(Star), R(0),
+ /* 1955 S> */ B(LdaConstant), U8(174),
+ /* 1957 E> */ B(Star), R(0),
+ /* 1966 S> */ B(LdaConstant), U8(175),
+ /* 1968 E> */ B(Star), R(0),
+ /* 1977 S> */ B(LdaConstant), U8(176),
+ /* 1979 E> */ B(Star), R(0),
+ /* 1988 S> */ B(LdaConstant), U8(177),
+ /* 1990 E> */ B(Star), R(0),
+ /* 1999 S> */ B(LdaConstant), U8(178),
+ /* 2001 E> */ B(Star), R(0),
+ /* 2010 S> */ B(LdaConstant), U8(179),
+ /* 2012 E> */ B(Star), R(0),
+ /* 2021 S> */ B(LdaConstant), U8(180),
+ /* 2023 E> */ B(Star), R(0),
+ /* 2032 S> */ B(LdaConstant), U8(181),
+ /* 2034 E> */ B(Star), R(0),
+ /* 2043 S> */ B(LdaConstant), U8(182),
+ /* 2045 E> */ B(Star), R(0),
+ /* 2054 S> */ B(LdaConstant), U8(183),
+ /* 2056 E> */ B(Star), R(0),
+ /* 2065 S> */ B(LdaConstant), U8(184),
+ /* 2067 E> */ B(Star), R(0),
+ /* 2076 S> */ B(LdaConstant), U8(185),
+ /* 2078 E> */ B(Star), R(0),
+ /* 2087 S> */ B(LdaConstant), U8(186),
+ /* 2089 E> */ B(Star), R(0),
+ /* 2098 S> */ B(LdaConstant), U8(187),
+ /* 2100 E> */ B(Star), R(0),
+ /* 2109 S> */ B(LdaConstant), U8(188),
+ /* 2111 E> */ B(Star), R(0),
+ /* 2120 S> */ B(LdaConstant), U8(189),
+ /* 2122 E> */ B(Star), R(0),
+ /* 2131 S> */ B(LdaConstant), U8(190),
+ /* 2133 E> */ B(Star), R(0),
+ /* 2142 S> */ B(LdaConstant), U8(191),
+ /* 2144 E> */ B(Star), R(0),
+ /* 2153 S> */ B(LdaConstant), U8(192),
+ /* 2155 E> */ B(Star), R(0),
+ /* 2164 S> */ B(LdaConstant), U8(193),
+ /* 2166 E> */ B(Star), R(0),
+ /* 2175 S> */ B(LdaConstant), U8(194),
+ /* 2177 E> */ B(Star), R(0),
+ /* 2186 S> */ B(LdaConstant), U8(195),
+ /* 2188 E> */ B(Star), R(0),
+ /* 2197 S> */ B(LdaConstant), U8(196),
+ /* 2199 E> */ B(Star), R(0),
+ /* 2208 S> */ B(LdaConstant), U8(197),
+ /* 2210 E> */ B(Star), R(0),
+ /* 2219 S> */ B(LdaConstant), U8(198),
+ /* 2221 E> */ B(Star), R(0),
+ /* 2230 S> */ B(LdaConstant), U8(199),
+ /* 2232 E> */ B(Star), R(0),
+ /* 2241 S> */ B(LdaConstant), U8(200),
+ /* 2243 E> */ B(Star), R(0),
+ /* 2252 S> */ B(LdaConstant), U8(201),
+ /* 2254 E> */ B(Star), R(0),
+ /* 2263 S> */ B(LdaConstant), U8(202),
+ /* 2265 E> */ B(Star), R(0),
+ /* 2274 S> */ B(LdaConstant), U8(203),
+ /* 2276 E> */ B(Star), R(0),
+ /* 2285 S> */ B(LdaConstant), U8(204),
+ /* 2287 E> */ B(Star), R(0),
+ /* 2296 S> */ B(LdaConstant), U8(205),
+ /* 2298 E> */ B(Star), R(0),
+ /* 2307 S> */ B(LdaConstant), U8(206),
+ /* 2309 E> */ B(Star), R(0),
+ /* 2318 S> */ B(LdaConstant), U8(207),
+ /* 2320 E> */ B(Star), R(0),
+ /* 2329 S> */ B(LdaConstant), U8(208),
+ /* 2331 E> */ B(Star), R(0),
+ /* 2340 S> */ B(LdaConstant), U8(209),
+ /* 2342 E> */ B(Star), R(0),
+ /* 2351 S> */ B(LdaConstant), U8(210),
+ /* 2353 E> */ B(Star), R(0),
+ /* 2362 S> */ B(LdaConstant), U8(211),
+ /* 2364 E> */ B(Star), R(0),
+ /* 2373 S> */ B(LdaConstant), U8(212),
+ /* 2375 E> */ B(Star), R(0),
+ /* 2384 S> */ B(LdaConstant), U8(213),
+ /* 2386 E> */ B(Star), R(0),
+ /* 2395 S> */ B(LdaConstant), U8(214),
+ /* 2397 E> */ B(Star), R(0),
+ /* 2406 S> */ B(LdaConstant), U8(215),
+ /* 2408 E> */ B(Star), R(0),
+ /* 2417 S> */ B(LdaConstant), U8(216),
+ /* 2419 E> */ B(Star), R(0),
+ /* 2428 S> */ B(LdaConstant), U8(217),
+ /* 2430 E> */ B(Star), R(0),
+ /* 2439 S> */ B(LdaConstant), U8(218),
+ /* 2441 E> */ B(Star), R(0),
+ /* 2450 S> */ B(LdaConstant), U8(219),
+ /* 2452 E> */ B(Star), R(0),
+ /* 2461 S> */ B(LdaConstant), U8(220),
+ /* 2463 E> */ B(Star), R(0),
+ /* 2472 S> */ B(LdaConstant), U8(221),
+ /* 2474 E> */ B(Star), R(0),
+ /* 2483 S> */ B(LdaConstant), U8(222),
+ /* 2485 E> */ B(Star), R(0),
+ /* 2494 S> */ B(LdaConstant), U8(223),
+ /* 2496 E> */ B(Star), R(0),
+ /* 2505 S> */ B(LdaConstant), U8(224),
+ /* 2507 E> */ B(Star), R(0),
+ /* 2516 S> */ B(LdaConstant), U8(225),
+ /* 2518 E> */ B(Star), R(0),
+ /* 2527 S> */ B(LdaConstant), U8(226),
+ /* 2529 E> */ B(Star), R(0),
+ /* 2538 S> */ B(LdaConstant), U8(227),
+ /* 2540 E> */ B(Star), R(0),
+ /* 2549 S> */ B(LdaConstant), U8(228),
+ /* 2551 E> */ B(Star), R(0),
+ /* 2560 S> */ B(LdaConstant), U8(229),
+ /* 2562 E> */ B(Star), R(0),
+ /* 2571 S> */ B(LdaConstant), U8(230),
+ /* 2573 E> */ B(Star), R(0),
+ /* 2582 S> */ B(LdaConstant), U8(231),
+ /* 2584 E> */ B(Star), R(0),
+ /* 2593 S> */ B(LdaConstant), U8(232),
+ /* 2595 E> */ B(Star), R(0),
+ /* 2604 S> */ B(LdaConstant), U8(233),
+ /* 2606 E> */ B(Star), R(0),
+ /* 2615 S> */ B(LdaConstant), U8(234),
+ /* 2617 E> */ B(Star), R(0),
+ /* 2626 S> */ B(LdaConstant), U8(235),
+ /* 2628 E> */ B(Star), R(0),
+ /* 2637 S> */ B(LdaConstant), U8(236),
+ /* 2639 E> */ B(Star), R(0),
+ /* 2648 S> */ B(LdaConstant), U8(237),
+ /* 2650 E> */ B(Star), R(0),
+ /* 2659 S> */ B(LdaConstant), U8(238),
+ /* 2661 E> */ B(Star), R(0),
+ /* 2670 S> */ B(LdaConstant), U8(239),
+ /* 2672 E> */ B(Star), R(0),
+ /* 2681 S> */ B(LdaConstant), U8(240),
+ /* 2683 E> */ B(Star), R(0),
+ /* 2692 S> */ B(LdaConstant), U8(241),
+ /* 2694 E> */ B(Star), R(0),
+ /* 2703 S> */ B(LdaConstant), U8(242),
+ /* 2705 E> */ B(Star), R(0),
+ /* 2714 S> */ B(LdaConstant), U8(243),
+ /* 2716 E> */ B(Star), R(0),
+ /* 2725 S> */ B(LdaConstant), U8(244),
+ /* 2727 E> */ B(Star), R(0),
+ /* 2736 S> */ B(LdaConstant), U8(245),
+ /* 2738 E> */ B(Star), R(0),
+ /* 2747 S> */ B(LdaConstant), U8(246),
+ /* 2749 E> */ B(Star), R(0),
+ /* 2758 S> */ B(LdaConstant), U8(247),
+ /* 2760 E> */ B(Star), R(0),
+ /* 2769 S> */ B(LdaConstant), U8(248),
+ /* 2771 E> */ B(Star), R(0),
+ /* 2780 S> */ B(LdaConstant), U8(249),
+ /* 2782 E> */ B(Star), R(0),
+ /* 2791 S> */ B(LdaConstant), U8(250),
+ /* 2793 E> */ B(Star), R(0),
+ /* 2802 S> */ B(LdaConstant), U8(251),
+ /* 2804 E> */ B(Star), R(0),
+ /* 2813 S> */ B(LdaConstant), U8(252),
+ /* 2815 E> */ B(Star), R(0),
+ /* 2824 S> */ B(LdaConstant), U8(253),
+ /* 2826 E> */ B(Star), R(0),
+ /* 2835 S> */ B(LdaConstant), U8(254),
+ /* 2837 E> */ B(Star), R(0),
+ /* 2846 S> */ B(LdaConstant), U8(255),
+ /* 2848 E> */ B(Star), R(0),
+ /* 2857 S> */ B(Wide), B(LdaConstant), U16(256),
+ /* 2859 E> */ B(Star), R(0),
+ B(LdaUndefined),
+ /* 2867 S> */ B(Return),
]
constant pool: [
1.414,
diff --git a/test/cctest/interpreter/bytecode_expectations/IfConditions.golden b/test/cctest/interpreter/bytecode_expectations/IfConditions.golden
index f450f3f..2d66970 100644
--- a/test/cctest/interpreter/bytecode_expectations/IfConditions.golden
+++ b/test/cctest/interpreter/bytecode_expectations/IfConditions.golden
@@ -3,7 +3,7 @@
#
---
-pool type: number
+pool type: mixed
execute: yes
wrap: no
test function name: f
@@ -23,9 +23,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(-1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 55 S> */ B(LdaSmi), U8(-1),
+ /* 70 S> */ B(Return),
]
constant pool: [
]
@@ -47,9 +47,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 36 S> */ B(LdaSmi), U8(1),
+ /* 76 S> */ B(Return),
]
constant pool: [
]
@@ -71,9 +71,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(-1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 59 S> */ B(LdaSmi), U8(-1),
+ /* 74 S> */ B(Return),
]
constant pool: [
]
@@ -93,9 +93,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 17 S> */ B(LdaUndefined),
+ /* 48 S> */ B(Return),
]
constant pool: [
]
@@ -118,20 +118,20 @@
parameter count: 1
bytecode array length: 24
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(JumpIfToBooleanFalse), U8(14),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Add), R(1),
- B(Star), R(0),
- B(Jump), U8(5),
- B(LdaSmi), U8(2),
- B(Return),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 25 S> */ B(LdaSmi), U8(1),
+ /* 25 E> */ B(Star), R(0),
+ /* 30 S> */ B(JumpIfToBooleanFalse), U8(14),
+ /* 43 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Add), R(1),
+ /* 45 E> */ B(Star), R(0),
+ B(Jump), U8(5),
+ /* 66 S> */ B(LdaSmi), U8(2),
+ /* 80 S> */ B(Return),
+ B(LdaUndefined),
+ /* 80 S> */ B(Return),
]
constant pool: [
]
@@ -153,18 +153,18 @@
parameter count: 2
bytecode array length: 22
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaZero),
- B(TestLessThanOrEqual), R(0),
- B(JumpIfFalse), U8(7),
- B(Wide), B(LdaSmi), U16(200),
- B(Return),
- B(Wide), B(LdaSmi), U16(-200),
- B(Return),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 18 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaZero),
+ /* 24 E> */ B(TestLessThanOrEqual), R(0),
+ B(JumpIfFalse), U8(7),
+ /* 36 S> */ B(Wide), B(LdaSmi), U16(200),
+ /* 80 S> */ B(Return),
+ /* 63 S> */ B(Wide), B(LdaSmi), U16(-200),
+ /* 80 S> */ B(Return),
+ B(LdaUndefined),
+ /* 80 S> */ B(Return),
]
constant pool: [
]
@@ -179,16 +179,16 @@
parameter count: 3
bytecode array length: 18
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(TestIn), R(0),
- B(JumpIfFalse), U8(7),
- B(Wide), B(LdaSmi), U16(200),
- B(Return),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 19 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 28 E> */ B(Ldar), R(arg1),
+ /* 25 E> */ B(TestIn), R(0),
+ B(JumpIfFalse), U8(7),
+ /* 33 S> */ B(Wide), B(LdaSmi), U16(200),
+ /* 47 S> */ B(Return),
+ B(LdaUndefined),
+ /* 47 S> */ B(Return),
]
constant pool: [
]
@@ -268,155 +268,155 @@
parameter count: 2
bytecode array length: 287
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaZero),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaConstant), U8(0),
- B(TestEqualStrict), R(2),
- B(JumpIfFalseConstant), U8(1),
- B(Ldar), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Wide), B(LdaSmi), U16(200),
- B(Return),
- B(Wide), B(LdaSmi), U16(-200),
- B(Return),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 24 S> */ B(LdaZero),
+ /* 24 E> */ B(Star), R(0),
+ /* 35 S> */ B(LdaZero),
+ /* 35 E> */ B(Star), R(1),
+ /* 38 S> */ B(Ldar), R(0),
+ B(Star), R(2),
+ B(LdaConstant), U8(0),
+ /* 44 E> */ B(TestEqualStrict), R(2),
+ B(JumpIfFalseConstant), U8(1),
+ /* 58 S> */ B(Ldar), R(0),
+ /* 60 E> */ B(Star), R(1),
+ /* 65 S> */ B(Star), R(0),
+ /* 74 S> */ B(Star), R(1),
+ /* 81 S> */ B(Star), R(0),
+ /* 90 S> */ B(Star), R(1),
+ /* 97 S> */ B(Star), R(0),
+ /* 106 S> */ B(Star), R(1),
+ /* 113 S> */ B(Star), R(0),
+ /* 122 S> */ B(Star), R(1),
+ /* 129 S> */ B(Star), R(0),
+ /* 138 S> */ B(Star), R(1),
+ /* 145 S> */ B(Star), R(0),
+ /* 154 S> */ B(Star), R(1),
+ /* 161 S> */ B(Star), R(0),
+ /* 170 S> */ B(Star), R(1),
+ /* 177 S> */ B(Star), R(0),
+ /* 186 S> */ B(Star), R(1),
+ /* 193 S> */ B(Star), R(0),
+ /* 202 S> */ B(Star), R(1),
+ /* 209 S> */ B(Star), R(0),
+ /* 218 S> */ B(Star), R(1),
+ /* 225 S> */ B(Star), R(0),
+ /* 234 S> */ B(Star), R(1),
+ /* 241 S> */ B(Star), R(0),
+ /* 250 S> */ B(Star), R(1),
+ /* 257 S> */ B(Star), R(0),
+ /* 266 S> */ B(Star), R(1),
+ /* 273 S> */ B(Star), R(0),
+ /* 282 S> */ B(Star), R(1),
+ /* 289 S> */ B(Star), R(0),
+ /* 298 S> */ B(Star), R(1),
+ /* 305 S> */ B(Star), R(0),
+ /* 314 S> */ B(Star), R(1),
+ /* 321 S> */ B(Star), R(0),
+ /* 330 S> */ B(Star), R(1),
+ /* 337 S> */ B(Star), R(0),
+ /* 346 S> */ B(Star), R(1),
+ /* 353 S> */ B(Star), R(0),
+ /* 362 S> */ B(Star), R(1),
+ /* 369 S> */ B(Star), R(0),
+ /* 378 S> */ B(Star), R(1),
+ /* 385 S> */ B(Star), R(0),
+ /* 394 S> */ B(Star), R(1),
+ /* 401 S> */ B(Star), R(0),
+ /* 410 S> */ B(Star), R(1),
+ /* 417 S> */ B(Star), R(0),
+ /* 426 S> */ B(Star), R(1),
+ /* 433 S> */ B(Star), R(0),
+ /* 442 S> */ B(Star), R(1),
+ /* 449 S> */ B(Star), R(0),
+ /* 458 S> */ B(Star), R(1),
+ /* 465 S> */ B(Star), R(0),
+ /* 474 S> */ B(Star), R(1),
+ /* 481 S> */ B(Star), R(0),
+ /* 490 S> */ B(Star), R(1),
+ /* 497 S> */ B(Star), R(0),
+ /* 506 S> */ B(Star), R(1),
+ /* 513 S> */ B(Star), R(0),
+ /* 522 S> */ B(Star), R(1),
+ /* 529 S> */ B(Star), R(0),
+ /* 538 S> */ B(Star), R(1),
+ /* 545 S> */ B(Star), R(0),
+ /* 554 S> */ B(Star), R(1),
+ /* 561 S> */ B(Star), R(0),
+ /* 570 S> */ B(Star), R(1),
+ /* 577 S> */ B(Star), R(0),
+ /* 586 S> */ B(Star), R(1),
+ /* 593 S> */ B(Star), R(0),
+ /* 602 S> */ B(Star), R(1),
+ /* 609 S> */ B(Star), R(0),
+ /* 618 S> */ B(Star), R(1),
+ /* 625 S> */ B(Star), R(0),
+ /* 634 S> */ B(Star), R(1),
+ /* 641 S> */ B(Star), R(0),
+ /* 650 S> */ B(Star), R(1),
+ /* 657 S> */ B(Star), R(0),
+ /* 666 S> */ B(Star), R(1),
+ /* 673 S> */ B(Star), R(0),
+ /* 682 S> */ B(Star), R(1),
+ /* 689 S> */ B(Star), R(0),
+ /* 698 S> */ B(Star), R(1),
+ /* 705 S> */ B(Star), R(0),
+ /* 714 S> */ B(Star), R(1),
+ /* 721 S> */ B(Star), R(0),
+ /* 730 S> */ B(Star), R(1),
+ /* 737 S> */ B(Star), R(0),
+ /* 746 S> */ B(Star), R(1),
+ /* 753 S> */ B(Star), R(0),
+ /* 762 S> */ B(Star), R(1),
+ /* 769 S> */ B(Star), R(0),
+ /* 778 S> */ B(Star), R(1),
+ /* 785 S> */ B(Star), R(0),
+ /* 794 S> */ B(Star), R(1),
+ /* 801 S> */ B(Star), R(0),
+ /* 810 S> */ B(Star), R(1),
+ /* 817 S> */ B(Star), R(0),
+ /* 826 S> */ B(Star), R(1),
+ /* 833 S> */ B(Star), R(0),
+ /* 842 S> */ B(Star), R(1),
+ /* 849 S> */ B(Star), R(0),
+ /* 858 S> */ B(Star), R(1),
+ /* 865 S> */ B(Star), R(0),
+ /* 874 S> */ B(Star), R(1),
+ /* 881 S> */ B(Star), R(0),
+ /* 890 S> */ B(Star), R(1),
+ /* 897 S> */ B(Star), R(0),
+ /* 906 S> */ B(Star), R(1),
+ /* 913 S> */ B(Star), R(0),
+ /* 922 S> */ B(Star), R(1),
+ /* 929 S> */ B(Star), R(0),
+ /* 938 S> */ B(Star), R(1),
+ /* 945 S> */ B(Star), R(0),
+ /* 954 S> */ B(Star), R(1),
+ /* 961 S> */ B(Star), R(0),
+ /* 970 S> */ B(Star), R(1),
+ /* 977 S> */ B(Star), R(0),
+ /* 986 S> */ B(Star), R(1),
+ /* 993 S> */ B(Star), R(0),
+ /* 1002 S> */ B(Star), R(1),
+ /* 1009 S> */ B(Star), R(0),
+ /* 1018 S> */ B(Star), R(1),
+ /* 1025 S> */ B(Star), R(0),
+ /* 1034 S> */ B(Star), R(1),
+ /* 1041 S> */ B(Star), R(0),
+ /* 1050 S> */ B(Star), R(1),
+ /* 1057 S> */ B(Star), R(0),
+ /* 1066 S> */ B(Star), R(1),
+ /* 1073 S> */ B(Star), R(0),
+ /* 1081 S> */ B(Wide), B(LdaSmi), U16(200),
+ /* 1117 S> */ B(Return),
+ /* 1102 S> */ B(Wide), B(LdaSmi), U16(-200),
+ /* 1117 S> */ B(Return),
+ B(LdaUndefined),
+ /* 1117 S> */ B(Return),
]
constant pool: [
- 0.01,
- 265,
+ InstanceType::HEAP_NUMBER_TYPE,
+ kInstanceTypeDontCare,
]
handlers: [
]
@@ -498,151 +498,151 @@
parameter count: 1
bytecode array length: 281
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaZero),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfToBooleanFalseConstant), U8(0),
- B(Ldar), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Star), R(0),
- B(Wide), B(LdaSmi), U16(200),
- B(Return),
- B(Wide), B(LdaSmi), U16(-200),
- B(Return),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 25 S> */ B(LdaZero),
+ /* 25 E> */ B(Star), R(0),
+ /* 36 S> */ B(LdaZero),
+ /* 36 E> */ B(Star), R(1),
+ /* 41 S> */ B(Ldar), R(0),
+ B(JumpIfToBooleanFalseConstant), U8(0),
+ /* 52 S> */ B(Ldar), R(0),
+ /* 54 E> */ B(Star), R(1),
+ /* 59 S> */ B(Star), R(0),
+ /* 68 S> */ B(Star), R(1),
+ /* 75 S> */ B(Star), R(0),
+ /* 84 S> */ B(Star), R(1),
+ /* 91 S> */ B(Star), R(0),
+ /* 100 S> */ B(Star), R(1),
+ /* 107 S> */ B(Star), R(0),
+ /* 116 S> */ B(Star), R(1),
+ /* 123 S> */ B(Star), R(0),
+ /* 132 S> */ B(Star), R(1),
+ /* 139 S> */ B(Star), R(0),
+ /* 148 S> */ B(Star), R(1),
+ /* 155 S> */ B(Star), R(0),
+ /* 164 S> */ B(Star), R(1),
+ /* 171 S> */ B(Star), R(0),
+ /* 180 S> */ B(Star), R(1),
+ /* 187 S> */ B(Star), R(0),
+ /* 196 S> */ B(Star), R(1),
+ /* 203 S> */ B(Star), R(0),
+ /* 212 S> */ B(Star), R(1),
+ /* 219 S> */ B(Star), R(0),
+ /* 228 S> */ B(Star), R(1),
+ /* 235 S> */ B(Star), R(0),
+ /* 244 S> */ B(Star), R(1),
+ /* 251 S> */ B(Star), R(0),
+ /* 260 S> */ B(Star), R(1),
+ /* 267 S> */ B(Star), R(0),
+ /* 276 S> */ B(Star), R(1),
+ /* 283 S> */ B(Star), R(0),
+ /* 292 S> */ B(Star), R(1),
+ /* 299 S> */ B(Star), R(0),
+ /* 308 S> */ B(Star), R(1),
+ /* 315 S> */ B(Star), R(0),
+ /* 324 S> */ B(Star), R(1),
+ /* 331 S> */ B(Star), R(0),
+ /* 340 S> */ B(Star), R(1),
+ /* 347 S> */ B(Star), R(0),
+ /* 356 S> */ B(Star), R(1),
+ /* 363 S> */ B(Star), R(0),
+ /* 372 S> */ B(Star), R(1),
+ /* 379 S> */ B(Star), R(0),
+ /* 388 S> */ B(Star), R(1),
+ /* 395 S> */ B(Star), R(0),
+ /* 404 S> */ B(Star), R(1),
+ /* 411 S> */ B(Star), R(0),
+ /* 420 S> */ B(Star), R(1),
+ /* 427 S> */ B(Star), R(0),
+ /* 436 S> */ B(Star), R(1),
+ /* 443 S> */ B(Star), R(0),
+ /* 452 S> */ B(Star), R(1),
+ /* 459 S> */ B(Star), R(0),
+ /* 468 S> */ B(Star), R(1),
+ /* 475 S> */ B(Star), R(0),
+ /* 484 S> */ B(Star), R(1),
+ /* 491 S> */ B(Star), R(0),
+ /* 500 S> */ B(Star), R(1),
+ /* 507 S> */ B(Star), R(0),
+ /* 516 S> */ B(Star), R(1),
+ /* 523 S> */ B(Star), R(0),
+ /* 532 S> */ B(Star), R(1),
+ /* 539 S> */ B(Star), R(0),
+ /* 548 S> */ B(Star), R(1),
+ /* 555 S> */ B(Star), R(0),
+ /* 564 S> */ B(Star), R(1),
+ /* 571 S> */ B(Star), R(0),
+ /* 580 S> */ B(Star), R(1),
+ /* 587 S> */ B(Star), R(0),
+ /* 596 S> */ B(Star), R(1),
+ /* 603 S> */ B(Star), R(0),
+ /* 612 S> */ B(Star), R(1),
+ /* 619 S> */ B(Star), R(0),
+ /* 628 S> */ B(Star), R(1),
+ /* 635 S> */ B(Star), R(0),
+ /* 644 S> */ B(Star), R(1),
+ /* 651 S> */ B(Star), R(0),
+ /* 660 S> */ B(Star), R(1),
+ /* 667 S> */ B(Star), R(0),
+ /* 676 S> */ B(Star), R(1),
+ /* 683 S> */ B(Star), R(0),
+ /* 692 S> */ B(Star), R(1),
+ /* 699 S> */ B(Star), R(0),
+ /* 708 S> */ B(Star), R(1),
+ /* 715 S> */ B(Star), R(0),
+ /* 724 S> */ B(Star), R(1),
+ /* 731 S> */ B(Star), R(0),
+ /* 740 S> */ B(Star), R(1),
+ /* 747 S> */ B(Star), R(0),
+ /* 756 S> */ B(Star), R(1),
+ /* 763 S> */ B(Star), R(0),
+ /* 772 S> */ B(Star), R(1),
+ /* 779 S> */ B(Star), R(0),
+ /* 788 S> */ B(Star), R(1),
+ /* 795 S> */ B(Star), R(0),
+ /* 804 S> */ B(Star), R(1),
+ /* 811 S> */ B(Star), R(0),
+ /* 820 S> */ B(Star), R(1),
+ /* 827 S> */ B(Star), R(0),
+ /* 836 S> */ B(Star), R(1),
+ /* 843 S> */ B(Star), R(0),
+ /* 852 S> */ B(Star), R(1),
+ /* 859 S> */ B(Star), R(0),
+ /* 868 S> */ B(Star), R(1),
+ /* 875 S> */ B(Star), R(0),
+ /* 884 S> */ B(Star), R(1),
+ /* 891 S> */ B(Star), R(0),
+ /* 900 S> */ B(Star), R(1),
+ /* 907 S> */ B(Star), R(0),
+ /* 916 S> */ B(Star), R(1),
+ /* 923 S> */ B(Star), R(0),
+ /* 932 S> */ B(Star), R(1),
+ /* 939 S> */ B(Star), R(0),
+ /* 948 S> */ B(Star), R(1),
+ /* 955 S> */ B(Star), R(0),
+ /* 964 S> */ B(Star), R(1),
+ /* 971 S> */ B(Star), R(0),
+ /* 980 S> */ B(Star), R(1),
+ /* 987 S> */ B(Star), R(0),
+ /* 996 S> */ B(Star), R(1),
+ /* 1003 S> */ B(Star), R(0),
+ /* 1012 S> */ B(Star), R(1),
+ /* 1019 S> */ B(Star), R(0),
+ /* 1028 S> */ B(Star), R(1),
+ /* 1035 S> */ B(Star), R(0),
+ /* 1044 S> */ B(Star), R(1),
+ /* 1051 S> */ B(Star), R(0),
+ /* 1060 S> */ B(Star), R(1),
+ /* 1067 S> */ B(Star), R(0),
+ /* 1076 S> */ B(Wide), B(LdaSmi), U16(200),
+ /* 1112 S> */ B(Return),
+ /* 1097 S> */ B(Wide), B(LdaSmi), U16(-200),
+ /* 1112 S> */ B(Return),
+ B(LdaUndefined),
+ /* 1112 S> */ B(Return),
]
constant pool: [
- 265,
+ kInstanceTypeDontCare,
]
handlers: [
]
@@ -666,65 +666,65 @@
parameter count: 3
bytecode array length: 107
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(TestEqual), R(0),
- B(JumpIfFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(TestEqualStrict), R(0),
- B(JumpIfFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(TestLessThan), R(0),
- B(JumpIfFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(TestGreaterThan), R(0),
- B(JumpIfFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(TestLessThanOrEqual), R(0),
- B(JumpIfFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(TestGreaterThanOrEqual), R(0),
- B(JumpIfFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(TestIn), R(0),
- B(JumpIfFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(TestInstanceOf), R(0),
- B(JumpIfFalse), U8(5),
- B(LdaSmi), U8(1),
- B(Return),
- B(LdaZero),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 21 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 30 E> */ B(Ldar), R(arg1),
+ /* 27 E> */ B(TestEqual), R(0),
+ B(JumpIfFalse), U8(5),
+ /* 35 S> */ B(LdaSmi), U8(1),
+ /* 262 S> */ B(Return),
+ /* 49 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 59 E> */ B(Ldar), R(arg1),
+ /* 55 E> */ B(TestEqualStrict), R(0),
+ B(JumpIfFalse), U8(5),
+ /* 64 S> */ B(LdaSmi), U8(1),
+ /* 262 S> */ B(Return),
+ /* 78 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 86 E> */ B(Ldar), R(arg1),
+ /* 84 E> */ B(TestLessThan), R(0),
+ B(JumpIfFalse), U8(5),
+ /* 91 S> */ B(LdaSmi), U8(1),
+ /* 262 S> */ B(Return),
+ /* 105 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 113 E> */ B(Ldar), R(arg1),
+ /* 111 E> */ B(TestGreaterThan), R(0),
+ B(JumpIfFalse), U8(5),
+ /* 118 S> */ B(LdaSmi), U8(1),
+ /* 262 S> */ B(Return),
+ /* 132 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 141 E> */ B(Ldar), R(arg1),
+ /* 138 E> */ B(TestLessThanOrEqual), R(0),
+ B(JumpIfFalse), U8(5),
+ /* 146 S> */ B(LdaSmi), U8(1),
+ /* 262 S> */ B(Return),
+ /* 160 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 169 E> */ B(Ldar), R(arg1),
+ /* 166 E> */ B(TestGreaterThanOrEqual), R(0),
+ B(JumpIfFalse), U8(5),
+ /* 174 S> */ B(LdaSmi), U8(1),
+ /* 262 S> */ B(Return),
+ /* 188 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 197 E> */ B(Ldar), R(arg1),
+ /* 194 E> */ B(TestIn), R(0),
+ B(JumpIfFalse), U8(5),
+ /* 202 S> */ B(LdaSmi), U8(1),
+ /* 262 S> */ B(Return),
+ /* 216 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 233 E> */ B(Ldar), R(arg1),
+ /* 222 E> */ B(TestInstanceOf), R(0),
+ B(JumpIfFalse), U8(5),
+ /* 238 S> */ B(LdaSmi), U8(1),
+ /* 262 S> */ B(Return),
+ /* 252 S> */ B(LdaZero),
+ /* 262 S> */ B(Return),
]
constant pool: [
]
@@ -747,16 +747,16 @@
parameter count: 1
bytecode array length: 14
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(JumpIfToBooleanFalse), U8(5),
- B(LdaSmi), U8(20),
- B(Return),
- B(LdaSmi), U8(-20),
- B(Return),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 25 S> */ B(LdaZero),
+ /* 25 E> */ B(Star), R(0),
+ /* 30 S> */ B(JumpIfToBooleanFalse), U8(5),
+ /* 43 S> */ B(LdaSmi), U8(20),
+ /* 85 S> */ B(Return),
+ /* 69 S> */ B(LdaSmi), U8(-20),
+ /* 85 S> */ B(Return),
+ B(LdaUndefined),
+ /* 85 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/IntegerConstants.golden b/test/cctest/interpreter/bytecode_expectations/IntegerConstants.golden
index 1c37c12..f82e5f8 100644
--- a/test/cctest/interpreter/bytecode_expectations/IntegerConstants.golden
+++ b/test/cctest/interpreter/bytecode_expectations/IntegerConstants.golden
@@ -15,9 +15,9 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(ExtraWide), B(LdaSmi), U32(12345678),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(ExtraWide), B(LdaSmi), U32(12345678),
+ /* 51 S> */ B(Return),
]
constant pool: [
]
@@ -32,11 +32,11 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(Wide), B(LdaSmi), U16(1234),
- B(Star), R(0),
- B(Wide), B(LdaSmi), U16(5678),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(Wide), B(LdaSmi), U16(1234),
+ /* 42 E> */ B(Star), R(0),
+ /* 48 S> */ B(Wide), B(LdaSmi), U16(5678),
+ /* 61 S> */ B(Return),
]
constant pool: [
]
@@ -51,11 +51,11 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(Wide), B(LdaSmi), U16(1234),
- B(Star), R(0),
- B(Wide), B(LdaSmi), U16(1234),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(Wide), B(LdaSmi), U16(1234),
+ /* 42 E> */ B(Star), R(0),
+ /* 48 S> */ B(Wide), B(LdaSmi), U16(1234),
+ /* 61 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/JumpsRequiringConstantWideOperands.golden b/test/cctest/interpreter/bytecode_expectations/JumpsRequiringConstantWideOperands.golden
index 3f0b49d..84810b1 100644
--- a/test/cctest/interpreter/bytecode_expectations/JumpsRequiringConstantWideOperands.golden
+++ b/test/cctest/interpreter/bytecode_expectations/JumpsRequiringConstantWideOperands.golden
@@ -331,659 +331,659 @@
parameter count: 1
bytecode array length: 1422
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(2),
- B(Star), R(0),
- B(LdaConstant), U8(3),
- B(Star), R(0),
- B(LdaConstant), U8(4),
- B(Star), R(0),
- B(LdaConstant), U8(5),
- B(Star), R(0),
- B(LdaConstant), U8(6),
- B(Star), R(0),
- B(LdaConstant), U8(7),
- B(Star), R(0),
- B(LdaConstant), U8(8),
- B(Star), R(0),
- B(LdaConstant), U8(9),
- B(Star), R(0),
- B(LdaConstant), U8(10),
- B(Star), R(0),
- B(LdaConstant), U8(11),
- B(Star), R(0),
- B(LdaConstant), U8(12),
- B(Star), R(0),
- B(LdaConstant), U8(13),
- B(Star), R(0),
- B(LdaConstant), U8(14),
- B(Star), R(0),
- B(LdaConstant), U8(15),
- B(Star), R(0),
- B(LdaConstant), U8(16),
- B(Star), R(0),
- B(LdaConstant), U8(17),
- B(Star), R(0),
- B(LdaConstant), U8(18),
- B(Star), R(0),
- B(LdaConstant), U8(19),
- B(Star), R(0),
- B(LdaConstant), U8(20),
- B(Star), R(0),
- B(LdaConstant), U8(21),
- B(Star), R(0),
- B(LdaConstant), U8(22),
- B(Star), R(0),
- B(LdaConstant), U8(23),
- B(Star), R(0),
- B(LdaConstant), U8(24),
- B(Star), R(0),
- B(LdaConstant), U8(25),
- B(Star), R(0),
- B(LdaConstant), U8(26),
- B(Star), R(0),
- B(LdaConstant), U8(27),
- B(Star), R(0),
- B(LdaConstant), U8(28),
- B(Star), R(0),
- B(LdaConstant), U8(29),
- B(Star), R(0),
- B(LdaConstant), U8(30),
- B(Star), R(0),
- B(LdaConstant), U8(31),
- B(Star), R(0),
- B(LdaConstant), U8(32),
- B(Star), R(0),
- B(LdaConstant), U8(33),
- B(Star), R(0),
- B(LdaConstant), U8(34),
- B(Star), R(0),
- B(LdaConstant), U8(35),
- B(Star), R(0),
- B(LdaConstant), U8(36),
- B(Star), R(0),
- B(LdaConstant), U8(37),
- B(Star), R(0),
- B(LdaConstant), U8(38),
- B(Star), R(0),
- B(LdaConstant), U8(39),
- B(Star), R(0),
- B(LdaConstant), U8(40),
- B(Star), R(0),
- B(LdaConstant), U8(41),
- B(Star), R(0),
- B(LdaConstant), U8(42),
- B(Star), R(0),
- B(LdaConstant), U8(43),
- B(Star), R(0),
- B(LdaConstant), U8(44),
- B(Star), R(0),
- B(LdaConstant), U8(45),
- B(Star), R(0),
- B(LdaConstant), U8(46),
- B(Star), R(0),
- B(LdaConstant), U8(47),
- B(Star), R(0),
- B(LdaConstant), U8(48),
- B(Star), R(0),
- B(LdaConstant), U8(49),
- B(Star), R(0),
- B(LdaConstant), U8(50),
- B(Star), R(0),
- B(LdaConstant), U8(51),
- B(Star), R(0),
- B(LdaConstant), U8(52),
- B(Star), R(0),
- B(LdaConstant), U8(53),
- B(Star), R(0),
- B(LdaConstant), U8(54),
- B(Star), R(0),
- B(LdaConstant), U8(55),
- B(Star), R(0),
- B(LdaConstant), U8(56),
- B(Star), R(0),
- B(LdaConstant), U8(57),
- B(Star), R(0),
- B(LdaConstant), U8(58),
- B(Star), R(0),
- B(LdaConstant), U8(59),
- B(Star), R(0),
- B(LdaConstant), U8(60),
- B(Star), R(0),
- B(LdaConstant), U8(61),
- B(Star), R(0),
- B(LdaConstant), U8(62),
- B(Star), R(0),
- B(LdaConstant), U8(63),
- B(Star), R(0),
- B(LdaConstant), U8(64),
- B(Star), R(0),
- B(LdaConstant), U8(65),
- B(Star), R(0),
- B(LdaConstant), U8(66),
- B(Star), R(0),
- B(LdaConstant), U8(67),
- B(Star), R(0),
- B(LdaConstant), U8(68),
- B(Star), R(0),
- B(LdaConstant), U8(69),
- B(Star), R(0),
- B(LdaConstant), U8(70),
- B(Star), R(0),
- B(LdaConstant), U8(71),
- B(Star), R(0),
- B(LdaConstant), U8(72),
- B(Star), R(0),
- B(LdaConstant), U8(73),
- B(Star), R(0),
- B(LdaConstant), U8(74),
- B(Star), R(0),
- B(LdaConstant), U8(75),
- B(Star), R(0),
- B(LdaConstant), U8(76),
- B(Star), R(0),
- B(LdaConstant), U8(77),
- B(Star), R(0),
- B(LdaConstant), U8(78),
- B(Star), R(0),
- B(LdaConstant), U8(79),
- B(Star), R(0),
- B(LdaConstant), U8(80),
- B(Star), R(0),
- B(LdaConstant), U8(81),
- B(Star), R(0),
- B(LdaConstant), U8(82),
- B(Star), R(0),
- B(LdaConstant), U8(83),
- B(Star), R(0),
- B(LdaConstant), U8(84),
- B(Star), R(0),
- B(LdaConstant), U8(85),
- B(Star), R(0),
- B(LdaConstant), U8(86),
- B(Star), R(0),
- B(LdaConstant), U8(87),
- B(Star), R(0),
- B(LdaConstant), U8(88),
- B(Star), R(0),
- B(LdaConstant), U8(89),
- B(Star), R(0),
- B(LdaConstant), U8(90),
- B(Star), R(0),
- B(LdaConstant), U8(91),
- B(Star), R(0),
- B(LdaConstant), U8(92),
- B(Star), R(0),
- B(LdaConstant), U8(93),
- B(Star), R(0),
- B(LdaConstant), U8(94),
- B(Star), R(0),
- B(LdaConstant), U8(95),
- B(Star), R(0),
- B(LdaConstant), U8(96),
- B(Star), R(0),
- B(LdaConstant), U8(97),
- B(Star), R(0),
- B(LdaConstant), U8(98),
- B(Star), R(0),
- B(LdaConstant), U8(99),
- B(Star), R(0),
- B(LdaConstant), U8(100),
- B(Star), R(0),
- B(LdaConstant), U8(101),
- B(Star), R(0),
- B(LdaConstant), U8(102),
- B(Star), R(0),
- B(LdaConstant), U8(103),
- B(Star), R(0),
- B(LdaConstant), U8(104),
- B(Star), R(0),
- B(LdaConstant), U8(105),
- B(Star), R(0),
- B(LdaConstant), U8(106),
- B(Star), R(0),
- B(LdaConstant), U8(107),
- B(Star), R(0),
- B(LdaConstant), U8(108),
- B(Star), R(0),
- B(LdaConstant), U8(109),
- B(Star), R(0),
- B(LdaConstant), U8(110),
- B(Star), R(0),
- B(LdaConstant), U8(111),
- B(Star), R(0),
- B(LdaConstant), U8(112),
- B(Star), R(0),
- B(LdaConstant), U8(113),
- B(Star), R(0),
- B(LdaConstant), U8(114),
- B(Star), R(0),
- B(LdaConstant), U8(115),
- B(Star), R(0),
- B(LdaConstant), U8(116),
- B(Star), R(0),
- B(LdaConstant), U8(117),
- B(Star), R(0),
- B(LdaConstant), U8(118),
- B(Star), R(0),
- B(LdaConstant), U8(119),
- B(Star), R(0),
- B(LdaConstant), U8(120),
- B(Star), R(0),
- B(LdaConstant), U8(121),
- B(Star), R(0),
- B(LdaConstant), U8(122),
- B(Star), R(0),
- B(LdaConstant), U8(123),
- B(Star), R(0),
- B(LdaConstant), U8(124),
- B(Star), R(0),
- B(LdaConstant), U8(125),
- B(Star), R(0),
- B(LdaConstant), U8(126),
- B(Star), R(0),
- B(LdaConstant), U8(127),
- B(Star), R(0),
- B(LdaConstant), U8(128),
- B(Star), R(0),
- B(LdaConstant), U8(129),
- B(Star), R(0),
- B(LdaConstant), U8(130),
- B(Star), R(0),
- B(LdaConstant), U8(131),
- B(Star), R(0),
- B(LdaConstant), U8(132),
- B(Star), R(0),
- B(LdaConstant), U8(133),
- B(Star), R(0),
- B(LdaConstant), U8(134),
- B(Star), R(0),
- B(LdaConstant), U8(135),
- B(Star), R(0),
- B(LdaConstant), U8(136),
- B(Star), R(0),
- B(LdaConstant), U8(137),
- B(Star), R(0),
- B(LdaConstant), U8(138),
- B(Star), R(0),
- B(LdaConstant), U8(139),
- B(Star), R(0),
- B(LdaConstant), U8(140),
- B(Star), R(0),
- B(LdaConstant), U8(141),
- B(Star), R(0),
- B(LdaConstant), U8(142),
- B(Star), R(0),
- B(LdaConstant), U8(143),
- B(Star), R(0),
- B(LdaConstant), U8(144),
- B(Star), R(0),
- B(LdaConstant), U8(145),
- B(Star), R(0),
- B(LdaConstant), U8(146),
- B(Star), R(0),
- B(LdaConstant), U8(147),
- B(Star), R(0),
- B(LdaConstant), U8(148),
- B(Star), R(0),
- B(LdaConstant), U8(149),
- B(Star), R(0),
- B(LdaConstant), U8(150),
- B(Star), R(0),
- B(LdaConstant), U8(151),
- B(Star), R(0),
- B(LdaConstant), U8(152),
- B(Star), R(0),
- B(LdaConstant), U8(153),
- B(Star), R(0),
- B(LdaConstant), U8(154),
- B(Star), R(0),
- B(LdaConstant), U8(155),
- B(Star), R(0),
- B(LdaConstant), U8(156),
- B(Star), R(0),
- B(LdaConstant), U8(157),
- B(Star), R(0),
- B(LdaConstant), U8(158),
- B(Star), R(0),
- B(LdaConstant), U8(159),
- B(Star), R(0),
- B(LdaConstant), U8(160),
- B(Star), R(0),
- B(LdaConstant), U8(161),
- B(Star), R(0),
- B(LdaConstant), U8(162),
- B(Star), R(0),
- B(LdaConstant), U8(163),
- B(Star), R(0),
- B(LdaConstant), U8(164),
- B(Star), R(0),
- B(LdaConstant), U8(165),
- B(Star), R(0),
- B(LdaConstant), U8(166),
- B(Star), R(0),
- B(LdaConstant), U8(167),
- B(Star), R(0),
- B(LdaConstant), U8(168),
- B(Star), R(0),
- B(LdaConstant), U8(169),
- B(Star), R(0),
- B(LdaConstant), U8(170),
- B(Star), R(0),
- B(LdaConstant), U8(171),
- B(Star), R(0),
- B(LdaConstant), U8(172),
- B(Star), R(0),
- B(LdaConstant), U8(173),
- B(Star), R(0),
- B(LdaConstant), U8(174),
- B(Star), R(0),
- B(LdaConstant), U8(175),
- B(Star), R(0),
- B(LdaConstant), U8(176),
- B(Star), R(0),
- B(LdaConstant), U8(177),
- B(Star), R(0),
- B(LdaConstant), U8(178),
- B(Star), R(0),
- B(LdaConstant), U8(179),
- B(Star), R(0),
- B(LdaConstant), U8(180),
- B(Star), R(0),
- B(LdaConstant), U8(181),
- B(Star), R(0),
- B(LdaConstant), U8(182),
- B(Star), R(0),
- B(LdaConstant), U8(183),
- B(Star), R(0),
- B(LdaConstant), U8(184),
- B(Star), R(0),
- B(LdaConstant), U8(185),
- B(Star), R(0),
- B(LdaConstant), U8(186),
- B(Star), R(0),
- B(LdaConstant), U8(187),
- B(Star), R(0),
- B(LdaConstant), U8(188),
- B(Star), R(0),
- B(LdaConstant), U8(189),
- B(Star), R(0),
- B(LdaConstant), U8(190),
- B(Star), R(0),
- B(LdaConstant), U8(191),
- B(Star), R(0),
- B(LdaConstant), U8(192),
- B(Star), R(0),
- B(LdaConstant), U8(193),
- B(Star), R(0),
- B(LdaConstant), U8(194),
- B(Star), R(0),
- B(LdaConstant), U8(195),
- B(Star), R(0),
- B(LdaConstant), U8(196),
- B(Star), R(0),
- B(LdaConstant), U8(197),
- B(Star), R(0),
- B(LdaConstant), U8(198),
- B(Star), R(0),
- B(LdaConstant), U8(199),
- B(Star), R(0),
- B(LdaConstant), U8(200),
- B(Star), R(0),
- B(LdaConstant), U8(201),
- B(Star), R(0),
- B(LdaConstant), U8(202),
- B(Star), R(0),
- B(LdaConstant), U8(203),
- B(Star), R(0),
- B(LdaConstant), U8(204),
- B(Star), R(0),
- B(LdaConstant), U8(205),
- B(Star), R(0),
- B(LdaConstant), U8(206),
- B(Star), R(0),
- B(LdaConstant), U8(207),
- B(Star), R(0),
- B(LdaConstant), U8(208),
- B(Star), R(0),
- B(LdaConstant), U8(209),
- B(Star), R(0),
- B(LdaConstant), U8(210),
- B(Star), R(0),
- B(LdaConstant), U8(211),
- B(Star), R(0),
- B(LdaConstant), U8(212),
- B(Star), R(0),
- B(LdaConstant), U8(213),
- B(Star), R(0),
- B(LdaConstant), U8(214),
- B(Star), R(0),
- B(LdaConstant), U8(215),
- B(Star), R(0),
- B(LdaConstant), U8(216),
- B(Star), R(0),
- B(LdaConstant), U8(217),
- B(Star), R(0),
- B(LdaConstant), U8(218),
- B(Star), R(0),
- B(LdaConstant), U8(219),
- B(Star), R(0),
- B(LdaConstant), U8(220),
- B(Star), R(0),
- B(LdaConstant), U8(221),
- B(Star), R(0),
- B(LdaConstant), U8(222),
- B(Star), R(0),
- B(LdaConstant), U8(223),
- B(Star), R(0),
- B(LdaConstant), U8(224),
- B(Star), R(0),
- B(LdaConstant), U8(225),
- B(Star), R(0),
- B(LdaConstant), U8(226),
- B(Star), R(0),
- B(LdaConstant), U8(227),
- B(Star), R(0),
- B(LdaConstant), U8(228),
- B(Star), R(0),
- B(LdaConstant), U8(229),
- B(Star), R(0),
- B(LdaConstant), U8(230),
- B(Star), R(0),
- B(LdaConstant), U8(231),
- B(Star), R(0),
- B(LdaConstant), U8(232),
- B(Star), R(0),
- B(LdaConstant), U8(233),
- B(Star), R(0),
- B(LdaConstant), U8(234),
- B(Star), R(0),
- B(LdaConstant), U8(235),
- B(Star), R(0),
- B(LdaConstant), U8(236),
- B(Star), R(0),
- B(LdaConstant), U8(237),
- B(Star), R(0),
- B(LdaConstant), U8(238),
- B(Star), R(0),
- B(LdaConstant), U8(239),
- B(Star), R(0),
- B(LdaConstant), U8(240),
- B(Star), R(0),
- B(LdaConstant), U8(241),
- B(Star), R(0),
- B(LdaConstant), U8(242),
- B(Star), R(0),
- B(LdaConstant), U8(243),
- B(Star), R(0),
- B(LdaConstant), U8(244),
- B(Star), R(0),
- B(LdaConstant), U8(245),
- B(Star), R(0),
- B(LdaConstant), U8(246),
- B(Star), R(0),
- B(LdaConstant), U8(247),
- B(Star), R(0),
- B(LdaConstant), U8(248),
- B(Star), R(0),
- B(LdaConstant), U8(249),
- B(Star), R(0),
- B(LdaConstant), U8(250),
- B(Star), R(0),
- B(LdaConstant), U8(251),
- B(Star), R(0),
- B(LdaConstant), U8(252),
- B(Star), R(0),
- B(LdaConstant), U8(253),
- B(Star), R(0),
- B(LdaConstant), U8(254),
- B(Star), R(0),
- B(LdaConstant), U8(255),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(256),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(257),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(258),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(259),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(260),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(261),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(262),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(263),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(264),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(265),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(266),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(267),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(268),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(269),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(270),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(271),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(272),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(273),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(274),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(275),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(276),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(277),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(278),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(279),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(280),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(281),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(282),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(283),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(284),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(285),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(286),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(287),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(288),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(289),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(290),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(291),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(292),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(293),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(294),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(295),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(296),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(297),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(298),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(299),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(300),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(301),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(302),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(303),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(304),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(305),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(306),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(307),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(308),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(309),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(310),
- B(Star), R(0),
- B(Wide), B(LdaConstant), U16(311),
- B(Star), R(0),
- B(LdaZero),
- B(Star), R(1),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(3),
- B(TestLessThan), R(2),
- B(Wide), B(JumpIfFalse), U16(46),
- B(StackCheck),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(TestEqual), R(2),
- B(Wide), B(JumpIfFalse), U16(7),
- B(Wide), B(Jump), U16(19),
- B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(2),
- B(TestEqual), R(2),
- B(Wide), B(JumpIfFalse), U16(7),
- B(Wide), B(Jump), U16(13),
- B(Ldar), R(1),
- B(ToNumber),
- B(Star), R(2),
- B(Inc),
- B(Star), R(1),
- B(Jump), U8(-53),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(0),
+ /* 55 S> */ B(LdaConstant), U8(1),
+ /* 55 E> */ B(Star), R(0),
+ /* 68 S> */ B(LdaConstant), U8(2),
+ /* 68 E> */ B(Star), R(0),
+ /* 81 S> */ B(LdaConstant), U8(3),
+ /* 81 E> */ B(Star), R(0),
+ /* 94 S> */ B(LdaConstant), U8(4),
+ /* 94 E> */ B(Star), R(0),
+ /* 107 S> */ B(LdaConstant), U8(5),
+ /* 107 E> */ B(Star), R(0),
+ /* 120 S> */ B(LdaConstant), U8(6),
+ /* 120 E> */ B(Star), R(0),
+ /* 133 S> */ B(LdaConstant), U8(7),
+ /* 133 E> */ B(Star), R(0),
+ /* 146 S> */ B(LdaConstant), U8(8),
+ /* 146 E> */ B(Star), R(0),
+ /* 159 S> */ B(LdaConstant), U8(9),
+ /* 159 E> */ B(Star), R(0),
+ /* 172 S> */ B(LdaConstant), U8(10),
+ /* 172 E> */ B(Star), R(0),
+ /* 185 S> */ B(LdaConstant), U8(11),
+ /* 185 E> */ B(Star), R(0),
+ /* 198 S> */ B(LdaConstant), U8(12),
+ /* 198 E> */ B(Star), R(0),
+ /* 211 S> */ B(LdaConstant), U8(13),
+ /* 211 E> */ B(Star), R(0),
+ /* 224 S> */ B(LdaConstant), U8(14),
+ /* 224 E> */ B(Star), R(0),
+ /* 237 S> */ B(LdaConstant), U8(15),
+ /* 237 E> */ B(Star), R(0),
+ /* 250 S> */ B(LdaConstant), U8(16),
+ /* 250 E> */ B(Star), R(0),
+ /* 263 S> */ B(LdaConstant), U8(17),
+ /* 263 E> */ B(Star), R(0),
+ /* 276 S> */ B(LdaConstant), U8(18),
+ /* 276 E> */ B(Star), R(0),
+ /* 289 S> */ B(LdaConstant), U8(19),
+ /* 289 E> */ B(Star), R(0),
+ /* 302 S> */ B(LdaConstant), U8(20),
+ /* 302 E> */ B(Star), R(0),
+ /* 315 S> */ B(LdaConstant), U8(21),
+ /* 315 E> */ B(Star), R(0),
+ /* 328 S> */ B(LdaConstant), U8(22),
+ /* 328 E> */ B(Star), R(0),
+ /* 341 S> */ B(LdaConstant), U8(23),
+ /* 341 E> */ B(Star), R(0),
+ /* 354 S> */ B(LdaConstant), U8(24),
+ /* 354 E> */ B(Star), R(0),
+ /* 367 S> */ B(LdaConstant), U8(25),
+ /* 367 E> */ B(Star), R(0),
+ /* 380 S> */ B(LdaConstant), U8(26),
+ /* 380 E> */ B(Star), R(0),
+ /* 393 S> */ B(LdaConstant), U8(27),
+ /* 393 E> */ B(Star), R(0),
+ /* 406 S> */ B(LdaConstant), U8(28),
+ /* 406 E> */ B(Star), R(0),
+ /* 419 S> */ B(LdaConstant), U8(29),
+ /* 419 E> */ B(Star), R(0),
+ /* 432 S> */ B(LdaConstant), U8(30),
+ /* 432 E> */ B(Star), R(0),
+ /* 445 S> */ B(LdaConstant), U8(31),
+ /* 445 E> */ B(Star), R(0),
+ /* 458 S> */ B(LdaConstant), U8(32),
+ /* 458 E> */ B(Star), R(0),
+ /* 471 S> */ B(LdaConstant), U8(33),
+ /* 471 E> */ B(Star), R(0),
+ /* 484 S> */ B(LdaConstant), U8(34),
+ /* 484 E> */ B(Star), R(0),
+ /* 497 S> */ B(LdaConstant), U8(35),
+ /* 497 E> */ B(Star), R(0),
+ /* 510 S> */ B(LdaConstant), U8(36),
+ /* 510 E> */ B(Star), R(0),
+ /* 523 S> */ B(LdaConstant), U8(37),
+ /* 523 E> */ B(Star), R(0),
+ /* 536 S> */ B(LdaConstant), U8(38),
+ /* 536 E> */ B(Star), R(0),
+ /* 549 S> */ B(LdaConstant), U8(39),
+ /* 549 E> */ B(Star), R(0),
+ /* 562 S> */ B(LdaConstant), U8(40),
+ /* 562 E> */ B(Star), R(0),
+ /* 575 S> */ B(LdaConstant), U8(41),
+ /* 575 E> */ B(Star), R(0),
+ /* 588 S> */ B(LdaConstant), U8(42),
+ /* 588 E> */ B(Star), R(0),
+ /* 601 S> */ B(LdaConstant), U8(43),
+ /* 601 E> */ B(Star), R(0),
+ /* 614 S> */ B(LdaConstant), U8(44),
+ /* 614 E> */ B(Star), R(0),
+ /* 627 S> */ B(LdaConstant), U8(45),
+ /* 627 E> */ B(Star), R(0),
+ /* 640 S> */ B(LdaConstant), U8(46),
+ /* 640 E> */ B(Star), R(0),
+ /* 653 S> */ B(LdaConstant), U8(47),
+ /* 653 E> */ B(Star), R(0),
+ /* 666 S> */ B(LdaConstant), U8(48),
+ /* 666 E> */ B(Star), R(0),
+ /* 679 S> */ B(LdaConstant), U8(49),
+ /* 679 E> */ B(Star), R(0),
+ /* 692 S> */ B(LdaConstant), U8(50),
+ /* 692 E> */ B(Star), R(0),
+ /* 705 S> */ B(LdaConstant), U8(51),
+ /* 705 E> */ B(Star), R(0),
+ /* 718 S> */ B(LdaConstant), U8(52),
+ /* 718 E> */ B(Star), R(0),
+ /* 731 S> */ B(LdaConstant), U8(53),
+ /* 731 E> */ B(Star), R(0),
+ /* 744 S> */ B(LdaConstant), U8(54),
+ /* 744 E> */ B(Star), R(0),
+ /* 757 S> */ B(LdaConstant), U8(55),
+ /* 757 E> */ B(Star), R(0),
+ /* 770 S> */ B(LdaConstant), U8(56),
+ /* 770 E> */ B(Star), R(0),
+ /* 783 S> */ B(LdaConstant), U8(57),
+ /* 783 E> */ B(Star), R(0),
+ /* 796 S> */ B(LdaConstant), U8(58),
+ /* 796 E> */ B(Star), R(0),
+ /* 809 S> */ B(LdaConstant), U8(59),
+ /* 809 E> */ B(Star), R(0),
+ /* 822 S> */ B(LdaConstant), U8(60),
+ /* 822 E> */ B(Star), R(0),
+ /* 835 S> */ B(LdaConstant), U8(61),
+ /* 835 E> */ B(Star), R(0),
+ /* 848 S> */ B(LdaConstant), U8(62),
+ /* 848 E> */ B(Star), R(0),
+ /* 861 S> */ B(LdaConstant), U8(63),
+ /* 861 E> */ B(Star), R(0),
+ /* 874 S> */ B(LdaConstant), U8(64),
+ /* 874 E> */ B(Star), R(0),
+ /* 887 S> */ B(LdaConstant), U8(65),
+ /* 887 E> */ B(Star), R(0),
+ /* 900 S> */ B(LdaConstant), U8(66),
+ /* 900 E> */ B(Star), R(0),
+ /* 913 S> */ B(LdaConstant), U8(67),
+ /* 913 E> */ B(Star), R(0),
+ /* 926 S> */ B(LdaConstant), U8(68),
+ /* 926 E> */ B(Star), R(0),
+ /* 939 S> */ B(LdaConstant), U8(69),
+ /* 939 E> */ B(Star), R(0),
+ /* 952 S> */ B(LdaConstant), U8(70),
+ /* 952 E> */ B(Star), R(0),
+ /* 965 S> */ B(LdaConstant), U8(71),
+ /* 965 E> */ B(Star), R(0),
+ /* 978 S> */ B(LdaConstant), U8(72),
+ /* 978 E> */ B(Star), R(0),
+ /* 991 S> */ B(LdaConstant), U8(73),
+ /* 991 E> */ B(Star), R(0),
+ /* 1004 S> */ B(LdaConstant), U8(74),
+ /* 1004 E> */ B(Star), R(0),
+ /* 1017 S> */ B(LdaConstant), U8(75),
+ /* 1017 E> */ B(Star), R(0),
+ /* 1030 S> */ B(LdaConstant), U8(76),
+ /* 1030 E> */ B(Star), R(0),
+ /* 1043 S> */ B(LdaConstant), U8(77),
+ /* 1043 E> */ B(Star), R(0),
+ /* 1056 S> */ B(LdaConstant), U8(78),
+ /* 1056 E> */ B(Star), R(0),
+ /* 1069 S> */ B(LdaConstant), U8(79),
+ /* 1069 E> */ B(Star), R(0),
+ /* 1082 S> */ B(LdaConstant), U8(80),
+ /* 1082 E> */ B(Star), R(0),
+ /* 1095 S> */ B(LdaConstant), U8(81),
+ /* 1095 E> */ B(Star), R(0),
+ /* 1108 S> */ B(LdaConstant), U8(82),
+ /* 1108 E> */ B(Star), R(0),
+ /* 1121 S> */ B(LdaConstant), U8(83),
+ /* 1121 E> */ B(Star), R(0),
+ /* 1134 S> */ B(LdaConstant), U8(84),
+ /* 1134 E> */ B(Star), R(0),
+ /* 1147 S> */ B(LdaConstant), U8(85),
+ /* 1147 E> */ B(Star), R(0),
+ /* 1160 S> */ B(LdaConstant), U8(86),
+ /* 1160 E> */ B(Star), R(0),
+ /* 1173 S> */ B(LdaConstant), U8(87),
+ /* 1173 E> */ B(Star), R(0),
+ /* 1186 S> */ B(LdaConstant), U8(88),
+ /* 1186 E> */ B(Star), R(0),
+ /* 1199 S> */ B(LdaConstant), U8(89),
+ /* 1199 E> */ B(Star), R(0),
+ /* 1212 S> */ B(LdaConstant), U8(90),
+ /* 1212 E> */ B(Star), R(0),
+ /* 1225 S> */ B(LdaConstant), U8(91),
+ /* 1225 E> */ B(Star), R(0),
+ /* 1238 S> */ B(LdaConstant), U8(92),
+ /* 1238 E> */ B(Star), R(0),
+ /* 1251 S> */ B(LdaConstant), U8(93),
+ /* 1251 E> */ B(Star), R(0),
+ /* 1264 S> */ B(LdaConstant), U8(94),
+ /* 1264 E> */ B(Star), R(0),
+ /* 1277 S> */ B(LdaConstant), U8(95),
+ /* 1277 E> */ B(Star), R(0),
+ /* 1290 S> */ B(LdaConstant), U8(96),
+ /* 1290 E> */ B(Star), R(0),
+ /* 1303 S> */ B(LdaConstant), U8(97),
+ /* 1303 E> */ B(Star), R(0),
+ /* 1316 S> */ B(LdaConstant), U8(98),
+ /* 1316 E> */ B(Star), R(0),
+ /* 1329 S> */ B(LdaConstant), U8(99),
+ /* 1329 E> */ B(Star), R(0),
+ /* 1342 S> */ B(LdaConstant), U8(100),
+ /* 1342 E> */ B(Star), R(0),
+ /* 1355 S> */ B(LdaConstant), U8(101),
+ /* 1355 E> */ B(Star), R(0),
+ /* 1368 S> */ B(LdaConstant), U8(102),
+ /* 1368 E> */ B(Star), R(0),
+ /* 1381 S> */ B(LdaConstant), U8(103),
+ /* 1381 E> */ B(Star), R(0),
+ /* 1394 S> */ B(LdaConstant), U8(104),
+ /* 1394 E> */ B(Star), R(0),
+ /* 1407 S> */ B(LdaConstant), U8(105),
+ /* 1407 E> */ B(Star), R(0),
+ /* 1420 S> */ B(LdaConstant), U8(106),
+ /* 1420 E> */ B(Star), R(0),
+ /* 1433 S> */ B(LdaConstant), U8(107),
+ /* 1433 E> */ B(Star), R(0),
+ /* 1446 S> */ B(LdaConstant), U8(108),
+ /* 1446 E> */ B(Star), R(0),
+ /* 1459 S> */ B(LdaConstant), U8(109),
+ /* 1459 E> */ B(Star), R(0),
+ /* 1472 S> */ B(LdaConstant), U8(110),
+ /* 1472 E> */ B(Star), R(0),
+ /* 1485 S> */ B(LdaConstant), U8(111),
+ /* 1485 E> */ B(Star), R(0),
+ /* 1498 S> */ B(LdaConstant), U8(112),
+ /* 1498 E> */ B(Star), R(0),
+ /* 1511 S> */ B(LdaConstant), U8(113),
+ /* 1511 E> */ B(Star), R(0),
+ /* 1524 S> */ B(LdaConstant), U8(114),
+ /* 1524 E> */ B(Star), R(0),
+ /* 1537 S> */ B(LdaConstant), U8(115),
+ /* 1537 E> */ B(Star), R(0),
+ /* 1550 S> */ B(LdaConstant), U8(116),
+ /* 1550 E> */ B(Star), R(0),
+ /* 1563 S> */ B(LdaConstant), U8(117),
+ /* 1563 E> */ B(Star), R(0),
+ /* 1576 S> */ B(LdaConstant), U8(118),
+ /* 1576 E> */ B(Star), R(0),
+ /* 1589 S> */ B(LdaConstant), U8(119),
+ /* 1589 E> */ B(Star), R(0),
+ /* 1602 S> */ B(LdaConstant), U8(120),
+ /* 1602 E> */ B(Star), R(0),
+ /* 1615 S> */ B(LdaConstant), U8(121),
+ /* 1615 E> */ B(Star), R(0),
+ /* 1628 S> */ B(LdaConstant), U8(122),
+ /* 1628 E> */ B(Star), R(0),
+ /* 1641 S> */ B(LdaConstant), U8(123),
+ /* 1641 E> */ B(Star), R(0),
+ /* 1654 S> */ B(LdaConstant), U8(124),
+ /* 1654 E> */ B(Star), R(0),
+ /* 1667 S> */ B(LdaConstant), U8(125),
+ /* 1667 E> */ B(Star), R(0),
+ /* 1680 S> */ B(LdaConstant), U8(126),
+ /* 1680 E> */ B(Star), R(0),
+ /* 1693 S> */ B(LdaConstant), U8(127),
+ /* 1693 E> */ B(Star), R(0),
+ /* 1706 S> */ B(LdaConstant), U8(128),
+ /* 1706 E> */ B(Star), R(0),
+ /* 1719 S> */ B(LdaConstant), U8(129),
+ /* 1719 E> */ B(Star), R(0),
+ /* 1732 S> */ B(LdaConstant), U8(130),
+ /* 1732 E> */ B(Star), R(0),
+ /* 1745 S> */ B(LdaConstant), U8(131),
+ /* 1745 E> */ B(Star), R(0),
+ /* 1758 S> */ B(LdaConstant), U8(132),
+ /* 1758 E> */ B(Star), R(0),
+ /* 1771 S> */ B(LdaConstant), U8(133),
+ /* 1771 E> */ B(Star), R(0),
+ /* 1784 S> */ B(LdaConstant), U8(134),
+ /* 1784 E> */ B(Star), R(0),
+ /* 1797 S> */ B(LdaConstant), U8(135),
+ /* 1797 E> */ B(Star), R(0),
+ /* 1810 S> */ B(LdaConstant), U8(136),
+ /* 1810 E> */ B(Star), R(0),
+ /* 1823 S> */ B(LdaConstant), U8(137),
+ /* 1823 E> */ B(Star), R(0),
+ /* 1836 S> */ B(LdaConstant), U8(138),
+ /* 1836 E> */ B(Star), R(0),
+ /* 1849 S> */ B(LdaConstant), U8(139),
+ /* 1849 E> */ B(Star), R(0),
+ /* 1862 S> */ B(LdaConstant), U8(140),
+ /* 1862 E> */ B(Star), R(0),
+ /* 1875 S> */ B(LdaConstant), U8(141),
+ /* 1875 E> */ B(Star), R(0),
+ /* 1888 S> */ B(LdaConstant), U8(142),
+ /* 1888 E> */ B(Star), R(0),
+ /* 1901 S> */ B(LdaConstant), U8(143),
+ /* 1901 E> */ B(Star), R(0),
+ /* 1914 S> */ B(LdaConstant), U8(144),
+ /* 1914 E> */ B(Star), R(0),
+ /* 1927 S> */ B(LdaConstant), U8(145),
+ /* 1927 E> */ B(Star), R(0),
+ /* 1940 S> */ B(LdaConstant), U8(146),
+ /* 1940 E> */ B(Star), R(0),
+ /* 1953 S> */ B(LdaConstant), U8(147),
+ /* 1953 E> */ B(Star), R(0),
+ /* 1966 S> */ B(LdaConstant), U8(148),
+ /* 1966 E> */ B(Star), R(0),
+ /* 1979 S> */ B(LdaConstant), U8(149),
+ /* 1979 E> */ B(Star), R(0),
+ /* 1992 S> */ B(LdaConstant), U8(150),
+ /* 1992 E> */ B(Star), R(0),
+ /* 2005 S> */ B(LdaConstant), U8(151),
+ /* 2005 E> */ B(Star), R(0),
+ /* 2018 S> */ B(LdaConstant), U8(152),
+ /* 2018 E> */ B(Star), R(0),
+ /* 2031 S> */ B(LdaConstant), U8(153),
+ /* 2031 E> */ B(Star), R(0),
+ /* 2044 S> */ B(LdaConstant), U8(154),
+ /* 2044 E> */ B(Star), R(0),
+ /* 2057 S> */ B(LdaConstant), U8(155),
+ /* 2057 E> */ B(Star), R(0),
+ /* 2070 S> */ B(LdaConstant), U8(156),
+ /* 2070 E> */ B(Star), R(0),
+ /* 2083 S> */ B(LdaConstant), U8(157),
+ /* 2083 E> */ B(Star), R(0),
+ /* 2096 S> */ B(LdaConstant), U8(158),
+ /* 2096 E> */ B(Star), R(0),
+ /* 2109 S> */ B(LdaConstant), U8(159),
+ /* 2109 E> */ B(Star), R(0),
+ /* 2122 S> */ B(LdaConstant), U8(160),
+ /* 2122 E> */ B(Star), R(0),
+ /* 2135 S> */ B(LdaConstant), U8(161),
+ /* 2135 E> */ B(Star), R(0),
+ /* 2148 S> */ B(LdaConstant), U8(162),
+ /* 2148 E> */ B(Star), R(0),
+ /* 2161 S> */ B(LdaConstant), U8(163),
+ /* 2161 E> */ B(Star), R(0),
+ /* 2174 S> */ B(LdaConstant), U8(164),
+ /* 2174 E> */ B(Star), R(0),
+ /* 2187 S> */ B(LdaConstant), U8(165),
+ /* 2187 E> */ B(Star), R(0),
+ /* 2200 S> */ B(LdaConstant), U8(166),
+ /* 2200 E> */ B(Star), R(0),
+ /* 2213 S> */ B(LdaConstant), U8(167),
+ /* 2213 E> */ B(Star), R(0),
+ /* 2226 S> */ B(LdaConstant), U8(168),
+ /* 2226 E> */ B(Star), R(0),
+ /* 2239 S> */ B(LdaConstant), U8(169),
+ /* 2239 E> */ B(Star), R(0),
+ /* 2252 S> */ B(LdaConstant), U8(170),
+ /* 2252 E> */ B(Star), R(0),
+ /* 2265 S> */ B(LdaConstant), U8(171),
+ /* 2265 E> */ B(Star), R(0),
+ /* 2278 S> */ B(LdaConstant), U8(172),
+ /* 2278 E> */ B(Star), R(0),
+ /* 2291 S> */ B(LdaConstant), U8(173),
+ /* 2291 E> */ B(Star), R(0),
+ /* 2304 S> */ B(LdaConstant), U8(174),
+ /* 2304 E> */ B(Star), R(0),
+ /* 2317 S> */ B(LdaConstant), U8(175),
+ /* 2317 E> */ B(Star), R(0),
+ /* 2330 S> */ B(LdaConstant), U8(176),
+ /* 2330 E> */ B(Star), R(0),
+ /* 2343 S> */ B(LdaConstant), U8(177),
+ /* 2343 E> */ B(Star), R(0),
+ /* 2356 S> */ B(LdaConstant), U8(178),
+ /* 2356 E> */ B(Star), R(0),
+ /* 2369 S> */ B(LdaConstant), U8(179),
+ /* 2369 E> */ B(Star), R(0),
+ /* 2382 S> */ B(LdaConstant), U8(180),
+ /* 2382 E> */ B(Star), R(0),
+ /* 2395 S> */ B(LdaConstant), U8(181),
+ /* 2395 E> */ B(Star), R(0),
+ /* 2408 S> */ B(LdaConstant), U8(182),
+ /* 2408 E> */ B(Star), R(0),
+ /* 2421 S> */ B(LdaConstant), U8(183),
+ /* 2421 E> */ B(Star), R(0),
+ /* 2434 S> */ B(LdaConstant), U8(184),
+ /* 2434 E> */ B(Star), R(0),
+ /* 2447 S> */ B(LdaConstant), U8(185),
+ /* 2447 E> */ B(Star), R(0),
+ /* 2460 S> */ B(LdaConstant), U8(186),
+ /* 2460 E> */ B(Star), R(0),
+ /* 2473 S> */ B(LdaConstant), U8(187),
+ /* 2473 E> */ B(Star), R(0),
+ /* 2486 S> */ B(LdaConstant), U8(188),
+ /* 2486 E> */ B(Star), R(0),
+ /* 2499 S> */ B(LdaConstant), U8(189),
+ /* 2499 E> */ B(Star), R(0),
+ /* 2512 S> */ B(LdaConstant), U8(190),
+ /* 2512 E> */ B(Star), R(0),
+ /* 2525 S> */ B(LdaConstant), U8(191),
+ /* 2525 E> */ B(Star), R(0),
+ /* 2538 S> */ B(LdaConstant), U8(192),
+ /* 2538 E> */ B(Star), R(0),
+ /* 2551 S> */ B(LdaConstant), U8(193),
+ /* 2551 E> */ B(Star), R(0),
+ /* 2564 S> */ B(LdaConstant), U8(194),
+ /* 2564 E> */ B(Star), R(0),
+ /* 2577 S> */ B(LdaConstant), U8(195),
+ /* 2577 E> */ B(Star), R(0),
+ /* 2590 S> */ B(LdaConstant), U8(196),
+ /* 2590 E> */ B(Star), R(0),
+ /* 2603 S> */ B(LdaConstant), U8(197),
+ /* 2603 E> */ B(Star), R(0),
+ /* 2616 S> */ B(LdaConstant), U8(198),
+ /* 2616 E> */ B(Star), R(0),
+ /* 2629 S> */ B(LdaConstant), U8(199),
+ /* 2629 E> */ B(Star), R(0),
+ /* 2642 S> */ B(LdaConstant), U8(200),
+ /* 2642 E> */ B(Star), R(0),
+ /* 2655 S> */ B(LdaConstant), U8(201),
+ /* 2655 E> */ B(Star), R(0),
+ /* 2668 S> */ B(LdaConstant), U8(202),
+ /* 2668 E> */ B(Star), R(0),
+ /* 2681 S> */ B(LdaConstant), U8(203),
+ /* 2681 E> */ B(Star), R(0),
+ /* 2694 S> */ B(LdaConstant), U8(204),
+ /* 2694 E> */ B(Star), R(0),
+ /* 2707 S> */ B(LdaConstant), U8(205),
+ /* 2707 E> */ B(Star), R(0),
+ /* 2720 S> */ B(LdaConstant), U8(206),
+ /* 2720 E> */ B(Star), R(0),
+ /* 2733 S> */ B(LdaConstant), U8(207),
+ /* 2733 E> */ B(Star), R(0),
+ /* 2746 S> */ B(LdaConstant), U8(208),
+ /* 2746 E> */ B(Star), R(0),
+ /* 2759 S> */ B(LdaConstant), U8(209),
+ /* 2759 E> */ B(Star), R(0),
+ /* 2772 S> */ B(LdaConstant), U8(210),
+ /* 2772 E> */ B(Star), R(0),
+ /* 2785 S> */ B(LdaConstant), U8(211),
+ /* 2785 E> */ B(Star), R(0),
+ /* 2798 S> */ B(LdaConstant), U8(212),
+ /* 2798 E> */ B(Star), R(0),
+ /* 2811 S> */ B(LdaConstant), U8(213),
+ /* 2811 E> */ B(Star), R(0),
+ /* 2824 S> */ B(LdaConstant), U8(214),
+ /* 2824 E> */ B(Star), R(0),
+ /* 2837 S> */ B(LdaConstant), U8(215),
+ /* 2837 E> */ B(Star), R(0),
+ /* 2850 S> */ B(LdaConstant), U8(216),
+ /* 2850 E> */ B(Star), R(0),
+ /* 2863 S> */ B(LdaConstant), U8(217),
+ /* 2863 E> */ B(Star), R(0),
+ /* 2876 S> */ B(LdaConstant), U8(218),
+ /* 2876 E> */ B(Star), R(0),
+ /* 2889 S> */ B(LdaConstant), U8(219),
+ /* 2889 E> */ B(Star), R(0),
+ /* 2902 S> */ B(LdaConstant), U8(220),
+ /* 2902 E> */ B(Star), R(0),
+ /* 2915 S> */ B(LdaConstant), U8(221),
+ /* 2915 E> */ B(Star), R(0),
+ /* 2928 S> */ B(LdaConstant), U8(222),
+ /* 2928 E> */ B(Star), R(0),
+ /* 2941 S> */ B(LdaConstant), U8(223),
+ /* 2941 E> */ B(Star), R(0),
+ /* 2954 S> */ B(LdaConstant), U8(224),
+ /* 2954 E> */ B(Star), R(0),
+ /* 2967 S> */ B(LdaConstant), U8(225),
+ /* 2967 E> */ B(Star), R(0),
+ /* 2980 S> */ B(LdaConstant), U8(226),
+ /* 2980 E> */ B(Star), R(0),
+ /* 2993 S> */ B(LdaConstant), U8(227),
+ /* 2993 E> */ B(Star), R(0),
+ /* 3006 S> */ B(LdaConstant), U8(228),
+ /* 3006 E> */ B(Star), R(0),
+ /* 3019 S> */ B(LdaConstant), U8(229),
+ /* 3019 E> */ B(Star), R(0),
+ /* 3032 S> */ B(LdaConstant), U8(230),
+ /* 3032 E> */ B(Star), R(0),
+ /* 3045 S> */ B(LdaConstant), U8(231),
+ /* 3045 E> */ B(Star), R(0),
+ /* 3058 S> */ B(LdaConstant), U8(232),
+ /* 3058 E> */ B(Star), R(0),
+ /* 3071 S> */ B(LdaConstant), U8(233),
+ /* 3071 E> */ B(Star), R(0),
+ /* 3084 S> */ B(LdaConstant), U8(234),
+ /* 3084 E> */ B(Star), R(0),
+ /* 3097 S> */ B(LdaConstant), U8(235),
+ /* 3097 E> */ B(Star), R(0),
+ /* 3110 S> */ B(LdaConstant), U8(236),
+ /* 3110 E> */ B(Star), R(0),
+ /* 3123 S> */ B(LdaConstant), U8(237),
+ /* 3123 E> */ B(Star), R(0),
+ /* 3136 S> */ B(LdaConstant), U8(238),
+ /* 3136 E> */ B(Star), R(0),
+ /* 3149 S> */ B(LdaConstant), U8(239),
+ /* 3149 E> */ B(Star), R(0),
+ /* 3162 S> */ B(LdaConstant), U8(240),
+ /* 3162 E> */ B(Star), R(0),
+ /* 3175 S> */ B(LdaConstant), U8(241),
+ /* 3175 E> */ B(Star), R(0),
+ /* 3188 S> */ B(LdaConstant), U8(242),
+ /* 3188 E> */ B(Star), R(0),
+ /* 3201 S> */ B(LdaConstant), U8(243),
+ /* 3201 E> */ B(Star), R(0),
+ /* 3214 S> */ B(LdaConstant), U8(244),
+ /* 3214 E> */ B(Star), R(0),
+ /* 3227 S> */ B(LdaConstant), U8(245),
+ /* 3227 E> */ B(Star), R(0),
+ /* 3240 S> */ B(LdaConstant), U8(246),
+ /* 3240 E> */ B(Star), R(0),
+ /* 3253 S> */ B(LdaConstant), U8(247),
+ /* 3253 E> */ B(Star), R(0),
+ /* 3266 S> */ B(LdaConstant), U8(248),
+ /* 3266 E> */ B(Star), R(0),
+ /* 3279 S> */ B(LdaConstant), U8(249),
+ /* 3279 E> */ B(Star), R(0),
+ /* 3292 S> */ B(LdaConstant), U8(250),
+ /* 3292 E> */ B(Star), R(0),
+ /* 3305 S> */ B(LdaConstant), U8(251),
+ /* 3305 E> */ B(Star), R(0),
+ /* 3318 S> */ B(LdaConstant), U8(252),
+ /* 3318 E> */ B(Star), R(0),
+ /* 3331 S> */ B(LdaConstant), U8(253),
+ /* 3331 E> */ B(Star), R(0),
+ /* 3344 S> */ B(LdaConstant), U8(254),
+ /* 3344 E> */ B(Star), R(0),
+ /* 3357 S> */ B(LdaConstant), U8(255),
+ /* 3357 E> */ B(Star), R(0),
+ /* 3370 S> */ B(Wide), B(LdaConstant), U16(256),
+ /* 3370 E> */ B(Star), R(0),
+ /* 3383 S> */ B(Wide), B(LdaConstant), U16(257),
+ /* 3383 E> */ B(Star), R(0),
+ /* 3396 S> */ B(Wide), B(LdaConstant), U16(258),
+ /* 3396 E> */ B(Star), R(0),
+ /* 3409 S> */ B(Wide), B(LdaConstant), U16(259),
+ /* 3409 E> */ B(Star), R(0),
+ /* 3422 S> */ B(Wide), B(LdaConstant), U16(260),
+ /* 3422 E> */ B(Star), R(0),
+ /* 3435 S> */ B(Wide), B(LdaConstant), U16(261),
+ /* 3435 E> */ B(Star), R(0),
+ /* 3448 S> */ B(Wide), B(LdaConstant), U16(262),
+ /* 3448 E> */ B(Star), R(0),
+ /* 3461 S> */ B(Wide), B(LdaConstant), U16(263),
+ /* 3461 E> */ B(Star), R(0),
+ /* 3474 S> */ B(Wide), B(LdaConstant), U16(264),
+ /* 3474 E> */ B(Star), R(0),
+ /* 3487 S> */ B(Wide), B(LdaConstant), U16(265),
+ /* 3487 E> */ B(Star), R(0),
+ /* 3500 S> */ B(Wide), B(LdaConstant), U16(266),
+ /* 3500 E> */ B(Star), R(0),
+ /* 3513 S> */ B(Wide), B(LdaConstant), U16(267),
+ /* 3513 E> */ B(Star), R(0),
+ /* 3526 S> */ B(Wide), B(LdaConstant), U16(268),
+ /* 3526 E> */ B(Star), R(0),
+ /* 3539 S> */ B(Wide), B(LdaConstant), U16(269),
+ /* 3539 E> */ B(Star), R(0),
+ /* 3552 S> */ B(Wide), B(LdaConstant), U16(270),
+ /* 3552 E> */ B(Star), R(0),
+ /* 3565 S> */ B(Wide), B(LdaConstant), U16(271),
+ /* 3565 E> */ B(Star), R(0),
+ /* 3578 S> */ B(Wide), B(LdaConstant), U16(272),
+ /* 3578 E> */ B(Star), R(0),
+ /* 3591 S> */ B(Wide), B(LdaConstant), U16(273),
+ /* 3591 E> */ B(Star), R(0),
+ /* 3604 S> */ B(Wide), B(LdaConstant), U16(274),
+ /* 3604 E> */ B(Star), R(0),
+ /* 3617 S> */ B(Wide), B(LdaConstant), U16(275),
+ /* 3617 E> */ B(Star), R(0),
+ /* 3630 S> */ B(Wide), B(LdaConstant), U16(276),
+ /* 3630 E> */ B(Star), R(0),
+ /* 3643 S> */ B(Wide), B(LdaConstant), U16(277),
+ /* 3643 E> */ B(Star), R(0),
+ /* 3656 S> */ B(Wide), B(LdaConstant), U16(278),
+ /* 3656 E> */ B(Star), R(0),
+ /* 3669 S> */ B(Wide), B(LdaConstant), U16(279),
+ /* 3669 E> */ B(Star), R(0),
+ /* 3682 S> */ B(Wide), B(LdaConstant), U16(280),
+ /* 3682 E> */ B(Star), R(0),
+ /* 3695 S> */ B(Wide), B(LdaConstant), U16(281),
+ /* 3695 E> */ B(Star), R(0),
+ /* 3708 S> */ B(Wide), B(LdaConstant), U16(282),
+ /* 3708 E> */ B(Star), R(0),
+ /* 3721 S> */ B(Wide), B(LdaConstant), U16(283),
+ /* 3721 E> */ B(Star), R(0),
+ /* 3734 S> */ B(Wide), B(LdaConstant), U16(284),
+ /* 3734 E> */ B(Star), R(0),
+ /* 3747 S> */ B(Wide), B(LdaConstant), U16(285),
+ /* 3747 E> */ B(Star), R(0),
+ /* 3760 S> */ B(Wide), B(LdaConstant), U16(286),
+ /* 3760 E> */ B(Star), R(0),
+ /* 3773 S> */ B(Wide), B(LdaConstant), U16(287),
+ /* 3773 E> */ B(Star), R(0),
+ /* 3786 S> */ B(Wide), B(LdaConstant), U16(288),
+ /* 3786 E> */ B(Star), R(0),
+ /* 3799 S> */ B(Wide), B(LdaConstant), U16(289),
+ /* 3799 E> */ B(Star), R(0),
+ /* 3812 S> */ B(Wide), B(LdaConstant), U16(290),
+ /* 3812 E> */ B(Star), R(0),
+ /* 3825 S> */ B(Wide), B(LdaConstant), U16(291),
+ /* 3825 E> */ B(Star), R(0),
+ /* 3838 S> */ B(Wide), B(LdaConstant), U16(292),
+ /* 3838 E> */ B(Star), R(0),
+ /* 3851 S> */ B(Wide), B(LdaConstant), U16(293),
+ /* 3851 E> */ B(Star), R(0),
+ /* 3864 S> */ B(Wide), B(LdaConstant), U16(294),
+ /* 3864 E> */ B(Star), R(0),
+ /* 3877 S> */ B(Wide), B(LdaConstant), U16(295),
+ /* 3877 E> */ B(Star), R(0),
+ /* 3890 S> */ B(Wide), B(LdaConstant), U16(296),
+ /* 3890 E> */ B(Star), R(0),
+ /* 3903 S> */ B(Wide), B(LdaConstant), U16(297),
+ /* 3903 E> */ B(Star), R(0),
+ /* 3916 S> */ B(Wide), B(LdaConstant), U16(298),
+ /* 3916 E> */ B(Star), R(0),
+ /* 3929 S> */ B(Wide), B(LdaConstant), U16(299),
+ /* 3929 E> */ B(Star), R(0),
+ /* 3942 S> */ B(Wide), B(LdaConstant), U16(300),
+ /* 3942 E> */ B(Star), R(0),
+ /* 3955 S> */ B(Wide), B(LdaConstant), U16(301),
+ /* 3955 E> */ B(Star), R(0),
+ /* 3968 S> */ B(Wide), B(LdaConstant), U16(302),
+ /* 3968 E> */ B(Star), R(0),
+ /* 3981 S> */ B(Wide), B(LdaConstant), U16(303),
+ /* 3981 E> */ B(Star), R(0),
+ /* 3994 S> */ B(Wide), B(LdaConstant), U16(304),
+ /* 3994 E> */ B(Star), R(0),
+ /* 4007 S> */ B(Wide), B(LdaConstant), U16(305),
+ /* 4007 E> */ B(Star), R(0),
+ /* 4020 S> */ B(Wide), B(LdaConstant), U16(306),
+ /* 4020 E> */ B(Star), R(0),
+ /* 4033 S> */ B(Wide), B(LdaConstant), U16(307),
+ /* 4033 E> */ B(Star), R(0),
+ /* 4046 S> */ B(Wide), B(LdaConstant), U16(308),
+ /* 4046 E> */ B(Star), R(0),
+ /* 4059 S> */ B(Wide), B(LdaConstant), U16(309),
+ /* 4059 E> */ B(Star), R(0),
+ /* 4072 S> */ B(Wide), B(LdaConstant), U16(310),
+ /* 4072 E> */ B(Star), R(0),
+ /* 4085 S> */ B(Wide), B(LdaConstant), U16(311),
+ /* 4085 E> */ B(Star), R(0),
+ /* 4103 S> */ B(LdaZero),
+ /* 4103 E> */ B(Star), R(1),
+ /* 4108 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(3),
+ /* 4108 E> */ B(TestLessThan), R(2),
+ B(Wide), B(JumpIfFalse), U16(46),
+ /* 4090 E> */ B(StackCheck),
+ /* 4122 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 4128 E> */ B(TestEqual), R(2),
+ B(Wide), B(JumpIfFalse), U16(7),
+ /* 4134 S> */ B(Wide), B(Jump), U16(19),
+ /* 4146 S> */ B(Ldar), R(1),
+ B(Star), R(2),
+ B(LdaSmi), U8(2),
+ /* 4152 E> */ B(TestEqual), R(2),
+ B(Wide), B(JumpIfFalse), U16(7),
+ /* 4158 S> */ B(Wide), B(Jump), U16(13),
+ /* 4114 S> */ B(Ldar), R(1),
+ B(ToNumber),
+ B(Star), R(2),
+ B(Inc),
+ /* 4114 E> */ B(Star), R(1),
+ B(Jump), U8(-53),
+ /* 4167 S> */ B(LdaSmi), U8(3),
+ /* 4177 S> */ B(Return),
]
constant pool: [
0.1,
diff --git a/test/cctest/interpreter/bytecode_expectations/LetVariable.golden b/test/cctest/interpreter/bytecode_expectations/LetVariable.golden
index 5ceda85..3ac793a 100644
--- a/test/cctest/interpreter/bytecode_expectations/LetVariable.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LetVariable.golden
@@ -15,13 +15,13 @@
parameter count: 1
bytecode array length: 10
bytecodes: [
- B(LdaTheHole),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ B(LdaTheHole),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(Star), R(0),
+ B(LdaUndefined),
+ /* 46 S> */ B(Return),
]
constant pool: [
]
@@ -36,16 +36,16 @@
parameter count: 1
bytecode array length: 20
bytecodes: [
- B(LdaTheHole),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(1),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(1), U8(1),
- B(Return),
+ B(LdaTheHole),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(1), U8(1),
+ /* 56 S> */ B(Return),
]
constant pool: [
"x",
@@ -61,20 +61,20 @@
parameter count: 1
bytecode array length: 27
bytecodes: [
- B(LdaTheHole),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(20),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
- B(Ldar), R(1),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ B(LdaTheHole),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 45 S> */ B(LdaSmi), U8(20),
+ /* 45 E> */ B(Star), R(1),
+ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ B(Ldar), R(1),
+ B(Star), R(0),
+ /* 45 E> */ B(LdaUndefined),
+ /* 52 S> */ B(Return),
]
constant pool: [
"x",
@@ -90,22 +90,22 @@
parameter count: 1
bytecode array length: 31
bytecodes: [
- B(LdaTheHole),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(LdaSmi), U8(20),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
- B(Ldar), R(1),
- B(Star), R(0),
- B(LdaUndefined),
- B(Return),
+ B(LdaTheHole),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(LdaSmi), U8(20),
+ /* 48 E> */ B(Star), R(1),
+ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ B(Ldar), R(1),
+ B(Star), R(0),
+ B(LdaUndefined),
+ /* 54 S> */ B(Return),
]
constant pool: [
"x",
diff --git a/test/cctest/interpreter/bytecode_expectations/LetVariableContextSlot.golden b/test/cctest/interpreter/bytecode_expectations/LetVariableContextSlot.golden
index 4fc5c4f..591fe88 100644
--- a/test/cctest/interpreter/bytecode_expectations/LetVariableContextSlot.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LetVariableContextSlot.golden
@@ -15,17 +15,17 @@
parameter count: 1
bytecode array length: 24
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(StaContextSlot), R(context), U8(4),
- B(LdaUndefined),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(StaContextSlot), R(context), U8(4),
+ B(LdaUndefined),
+ /* 72 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -41,21 +41,21 @@
parameter count: 1
bytecode array length: 37
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(StaContextSlot), R(context), U8(4),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(1),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 72 S> */ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(1),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ /* 82 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -72,25 +72,25 @@
parameter count: 1
bytecode array length: 45
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(20),
- B(Star), R(2),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
- B(Ldar), R(2),
- B(StaContextSlot), R(context), U8(4),
- B(StaContextSlot), R(context), U8(4),
- B(LdaUndefined),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 45 S> */ B(LdaSmi), U8(20),
+ /* 45 E> */ B(Star), R(2),
+ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(Ldar), R(2),
+ B(StaContextSlot), R(context), U8(4),
+ /* 45 E> */ B(StaContextSlot), R(context), U8(4),
+ B(LdaUndefined),
+ /* 78 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
@@ -107,26 +107,26 @@
parameter count: 1
bytecode array length: 47
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(1),
- B(LdaTheHole),
- B(StaContextSlot), R(context), U8(4),
- B(CreateClosure), U8(0), U8(0),
- B(Star), R(0),
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(StaContextSlot), R(context), U8(4),
- B(LdaSmi), U8(20),
- B(Star), R(2),
- B(LdaContextSlot), R(context), U8(4),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
- B(Ldar), R(2),
- B(StaContextSlot), R(context), U8(4),
- B(LdaUndefined),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(LdaTheHole),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 46 S> */ B(LdaSmi), U8(20),
+ /* 48 E> */ B(Star), R(2),
+ B(LdaContextSlot), R(context), U8(4),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(Ldar), R(2),
+ B(StaContextSlot), R(context), U8(4),
+ B(LdaUndefined),
+ /* 80 S> */ B(Return),
]
constant pool: [
InstanceType::SHARED_FUNCTION_INFO_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/LoadGlobal.golden b/test/cctest/interpreter/bytecode_expectations/LoadGlobal.golden
index 0a96cae..7fb831b 100644
--- a/test/cctest/interpreter/bytecode_expectations/LoadGlobal.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LoadGlobal.golden
@@ -18,9 +18,9 @@
parameter count: 1
bytecode array length: 5
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(Return),
+ /* 21 E> */ B(StackCheck),
+ /* 26 S> */ B(LdaGlobal), U8(0), U8(1),
+ /* 36 S> */ B(Return),
]
constant pool: [
"a",
@@ -38,9 +38,9 @@
parameter count: 1
bytecode array length: 5
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(Return),
+ /* 27 E> */ B(StackCheck),
+ /* 32 S> */ B(LdaGlobal), U8(0), U8(1),
+ /* 42 S> */ B(Return),
]
constant pool: [
"t",
@@ -58,9 +58,9 @@
parameter count: 1
bytecode array length: 5
bytecodes: [
- B(StackCheck),
- B(LdaGlobal), U8(0), U8(1),
- B(Return),
+ /* 17 E> */ B(StackCheck),
+ /* 22 S> */ B(LdaGlobal), U8(0), U8(1),
+ /* 32 S> */ B(Return),
]
constant pool: [
"a",
@@ -208,393 +208,393 @@
parameter count: 2
bytecode array length: 1032
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(1),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(3),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(5),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(7),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(9),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(11),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(13),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(15),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(17),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(19),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(21),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(23),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(25),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(27),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(29),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(31),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(33),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(35),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(37),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(39),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(41),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(43),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(45),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(47),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(49),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(51),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(53),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(55),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(57),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(59),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(61),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(63),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(65),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(67),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(69),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(71),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(73),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(75),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(77),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(79),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(81),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(83),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(85),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(87),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(89),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(91),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(93),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(95),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(97),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(99),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(101),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(103),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(105),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(107),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(109),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(111),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(113),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(115),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(117),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(119),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(121),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(123),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(125),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(127),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(129),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(131),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(133),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(135),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(137),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(139),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(141),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(143),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(145),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(147),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(149),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(151),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(153),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(155),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(157),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(159),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(161),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(163),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(165),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(167),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(169),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(171),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(173),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(175),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(177),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(179),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(181),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(183),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(185),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(187),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(189),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(191),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(193),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(195),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(197),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(199),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(201),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(203),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(205),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(207),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(209),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(211),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(213),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(215),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(217),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(219),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(221),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(223),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(225),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(227),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(229),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(231),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(233),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(235),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(237),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(239),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(241),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(243),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(245),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(247),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(249),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(251),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(253),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(255),
- B(Wide), B(LdaGlobal), U16(1), U16(257),
- B(Return),
+ /* 17 E> */ B(StackCheck),
+ /* 25 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 26 E> */ B(LoadIC), R(0), U8(0), U8(1),
+ /* 35 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 36 E> */ B(LoadIC), R(0), U8(0), U8(3),
+ /* 45 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 46 E> */ B(LoadIC), R(0), U8(0), U8(5),
+ /* 55 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 56 E> */ B(LoadIC), R(0), U8(0), U8(7),
+ /* 65 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 66 E> */ B(LoadIC), R(0), U8(0), U8(9),
+ /* 75 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 76 E> */ B(LoadIC), R(0), U8(0), U8(11),
+ /* 85 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 86 E> */ B(LoadIC), R(0), U8(0), U8(13),
+ /* 95 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 96 E> */ B(LoadIC), R(0), U8(0), U8(15),
+ /* 105 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 106 E> */ B(LoadIC), R(0), U8(0), U8(17),
+ /* 115 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 116 E> */ B(LoadIC), R(0), U8(0), U8(19),
+ /* 125 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 126 E> */ B(LoadIC), R(0), U8(0), U8(21),
+ /* 135 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 136 E> */ B(LoadIC), R(0), U8(0), U8(23),
+ /* 145 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 146 E> */ B(LoadIC), R(0), U8(0), U8(25),
+ /* 155 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 156 E> */ B(LoadIC), R(0), U8(0), U8(27),
+ /* 165 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 166 E> */ B(LoadIC), R(0), U8(0), U8(29),
+ /* 175 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 176 E> */ B(LoadIC), R(0), U8(0), U8(31),
+ /* 185 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 186 E> */ B(LoadIC), R(0), U8(0), U8(33),
+ /* 195 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 196 E> */ B(LoadIC), R(0), U8(0), U8(35),
+ /* 205 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 206 E> */ B(LoadIC), R(0), U8(0), U8(37),
+ /* 215 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 216 E> */ B(LoadIC), R(0), U8(0), U8(39),
+ /* 225 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 226 E> */ B(LoadIC), R(0), U8(0), U8(41),
+ /* 235 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 236 E> */ B(LoadIC), R(0), U8(0), U8(43),
+ /* 245 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 246 E> */ B(LoadIC), R(0), U8(0), U8(45),
+ /* 255 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 256 E> */ B(LoadIC), R(0), U8(0), U8(47),
+ /* 265 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 266 E> */ B(LoadIC), R(0), U8(0), U8(49),
+ /* 275 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 276 E> */ B(LoadIC), R(0), U8(0), U8(51),
+ /* 285 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 286 E> */ B(LoadIC), R(0), U8(0), U8(53),
+ /* 295 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 296 E> */ B(LoadIC), R(0), U8(0), U8(55),
+ /* 305 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 306 E> */ B(LoadIC), R(0), U8(0), U8(57),
+ /* 315 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 316 E> */ B(LoadIC), R(0), U8(0), U8(59),
+ /* 325 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 326 E> */ B(LoadIC), R(0), U8(0), U8(61),
+ /* 335 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 336 E> */ B(LoadIC), R(0), U8(0), U8(63),
+ /* 345 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 346 E> */ B(LoadIC), R(0), U8(0), U8(65),
+ /* 355 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 356 E> */ B(LoadIC), R(0), U8(0), U8(67),
+ /* 365 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 366 E> */ B(LoadIC), R(0), U8(0), U8(69),
+ /* 375 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 376 E> */ B(LoadIC), R(0), U8(0), U8(71),
+ /* 385 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 386 E> */ B(LoadIC), R(0), U8(0), U8(73),
+ /* 395 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 396 E> */ B(LoadIC), R(0), U8(0), U8(75),
+ /* 405 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 406 E> */ B(LoadIC), R(0), U8(0), U8(77),
+ /* 415 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 416 E> */ B(LoadIC), R(0), U8(0), U8(79),
+ /* 425 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 426 E> */ B(LoadIC), R(0), U8(0), U8(81),
+ /* 435 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 436 E> */ B(LoadIC), R(0), U8(0), U8(83),
+ /* 445 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 446 E> */ B(LoadIC), R(0), U8(0), U8(85),
+ /* 455 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 456 E> */ B(LoadIC), R(0), U8(0), U8(87),
+ /* 465 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 466 E> */ B(LoadIC), R(0), U8(0), U8(89),
+ /* 475 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 476 E> */ B(LoadIC), R(0), U8(0), U8(91),
+ /* 485 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 486 E> */ B(LoadIC), R(0), U8(0), U8(93),
+ /* 495 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 496 E> */ B(LoadIC), R(0), U8(0), U8(95),
+ /* 505 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 506 E> */ B(LoadIC), R(0), U8(0), U8(97),
+ /* 515 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 516 E> */ B(LoadIC), R(0), U8(0), U8(99),
+ /* 525 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 526 E> */ B(LoadIC), R(0), U8(0), U8(101),
+ /* 535 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 536 E> */ B(LoadIC), R(0), U8(0), U8(103),
+ /* 545 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 546 E> */ B(LoadIC), R(0), U8(0), U8(105),
+ /* 555 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 556 E> */ B(LoadIC), R(0), U8(0), U8(107),
+ /* 565 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 566 E> */ B(LoadIC), R(0), U8(0), U8(109),
+ /* 575 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 576 E> */ B(LoadIC), R(0), U8(0), U8(111),
+ /* 585 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 586 E> */ B(LoadIC), R(0), U8(0), U8(113),
+ /* 595 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 596 E> */ B(LoadIC), R(0), U8(0), U8(115),
+ /* 605 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 606 E> */ B(LoadIC), R(0), U8(0), U8(117),
+ /* 615 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 616 E> */ B(LoadIC), R(0), U8(0), U8(119),
+ /* 625 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 626 E> */ B(LoadIC), R(0), U8(0), U8(121),
+ /* 635 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 636 E> */ B(LoadIC), R(0), U8(0), U8(123),
+ /* 645 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 646 E> */ B(LoadIC), R(0), U8(0), U8(125),
+ /* 655 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 656 E> */ B(LoadIC), R(0), U8(0), U8(127),
+ /* 665 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 666 E> */ B(LoadIC), R(0), U8(0), U8(129),
+ /* 675 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 676 E> */ B(LoadIC), R(0), U8(0), U8(131),
+ /* 685 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 686 E> */ B(LoadIC), R(0), U8(0), U8(133),
+ /* 695 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 696 E> */ B(LoadIC), R(0), U8(0), U8(135),
+ /* 705 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 706 E> */ B(LoadIC), R(0), U8(0), U8(137),
+ /* 715 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 716 E> */ B(LoadIC), R(0), U8(0), U8(139),
+ /* 725 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 726 E> */ B(LoadIC), R(0), U8(0), U8(141),
+ /* 735 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 736 E> */ B(LoadIC), R(0), U8(0), U8(143),
+ /* 745 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 746 E> */ B(LoadIC), R(0), U8(0), U8(145),
+ /* 755 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 756 E> */ B(LoadIC), R(0), U8(0), U8(147),
+ /* 765 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 766 E> */ B(LoadIC), R(0), U8(0), U8(149),
+ /* 775 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 776 E> */ B(LoadIC), R(0), U8(0), U8(151),
+ /* 785 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 786 E> */ B(LoadIC), R(0), U8(0), U8(153),
+ /* 795 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 796 E> */ B(LoadIC), R(0), U8(0), U8(155),
+ /* 805 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 806 E> */ B(LoadIC), R(0), U8(0), U8(157),
+ /* 815 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 816 E> */ B(LoadIC), R(0), U8(0), U8(159),
+ /* 825 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 826 E> */ B(LoadIC), R(0), U8(0), U8(161),
+ /* 835 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 836 E> */ B(LoadIC), R(0), U8(0), U8(163),
+ /* 845 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 846 E> */ B(LoadIC), R(0), U8(0), U8(165),
+ /* 855 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 856 E> */ B(LoadIC), R(0), U8(0), U8(167),
+ /* 865 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 866 E> */ B(LoadIC), R(0), U8(0), U8(169),
+ /* 875 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 876 E> */ B(LoadIC), R(0), U8(0), U8(171),
+ /* 885 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 886 E> */ B(LoadIC), R(0), U8(0), U8(173),
+ /* 895 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 896 E> */ B(LoadIC), R(0), U8(0), U8(175),
+ /* 905 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 906 E> */ B(LoadIC), R(0), U8(0), U8(177),
+ /* 915 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 916 E> */ B(LoadIC), R(0), U8(0), U8(179),
+ /* 925 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 926 E> */ B(LoadIC), R(0), U8(0), U8(181),
+ /* 935 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 936 E> */ B(LoadIC), R(0), U8(0), U8(183),
+ /* 945 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 946 E> */ B(LoadIC), R(0), U8(0), U8(185),
+ /* 955 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 956 E> */ B(LoadIC), R(0), U8(0), U8(187),
+ /* 965 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 966 E> */ B(LoadIC), R(0), U8(0), U8(189),
+ /* 975 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 976 E> */ B(LoadIC), R(0), U8(0), U8(191),
+ /* 985 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 986 E> */ B(LoadIC), R(0), U8(0), U8(193),
+ /* 995 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 996 E> */ B(LoadIC), R(0), U8(0), U8(195),
+ /* 1005 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1006 E> */ B(LoadIC), R(0), U8(0), U8(197),
+ /* 1015 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1016 E> */ B(LoadIC), R(0), U8(0), U8(199),
+ /* 1025 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1026 E> */ B(LoadIC), R(0), U8(0), U8(201),
+ /* 1035 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1036 E> */ B(LoadIC), R(0), U8(0), U8(203),
+ /* 1045 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1046 E> */ B(LoadIC), R(0), U8(0), U8(205),
+ /* 1055 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1056 E> */ B(LoadIC), R(0), U8(0), U8(207),
+ /* 1065 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1066 E> */ B(LoadIC), R(0), U8(0), U8(209),
+ /* 1075 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1076 E> */ B(LoadIC), R(0), U8(0), U8(211),
+ /* 1085 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1086 E> */ B(LoadIC), R(0), U8(0), U8(213),
+ /* 1095 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1096 E> */ B(LoadIC), R(0), U8(0), U8(215),
+ /* 1105 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1106 E> */ B(LoadIC), R(0), U8(0), U8(217),
+ /* 1115 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1116 E> */ B(LoadIC), R(0), U8(0), U8(219),
+ /* 1125 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1126 E> */ B(LoadIC), R(0), U8(0), U8(221),
+ /* 1135 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1136 E> */ B(LoadIC), R(0), U8(0), U8(223),
+ /* 1145 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1146 E> */ B(LoadIC), R(0), U8(0), U8(225),
+ /* 1155 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1156 E> */ B(LoadIC), R(0), U8(0), U8(227),
+ /* 1165 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1166 E> */ B(LoadIC), R(0), U8(0), U8(229),
+ /* 1175 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1176 E> */ B(LoadIC), R(0), U8(0), U8(231),
+ /* 1185 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1186 E> */ B(LoadIC), R(0), U8(0), U8(233),
+ /* 1195 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1196 E> */ B(LoadIC), R(0), U8(0), U8(235),
+ /* 1205 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1206 E> */ B(LoadIC), R(0), U8(0), U8(237),
+ /* 1215 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1216 E> */ B(LoadIC), R(0), U8(0), U8(239),
+ /* 1225 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1226 E> */ B(LoadIC), R(0), U8(0), U8(241),
+ /* 1235 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1236 E> */ B(LoadIC), R(0), U8(0), U8(243),
+ /* 1245 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1246 E> */ B(LoadIC), R(0), U8(0), U8(245),
+ /* 1255 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1256 E> */ B(LoadIC), R(0), U8(0), U8(247),
+ /* 1265 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1266 E> */ B(LoadIC), R(0), U8(0), U8(249),
+ /* 1275 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1276 E> */ B(LoadIC), R(0), U8(0), U8(251),
+ /* 1285 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1286 E> */ B(LoadIC), R(0), U8(0), U8(253),
+ /* 1295 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1296 E> */ B(LoadIC), R(0), U8(0), U8(255),
+ /* 1305 S> */ B(Wide), B(LdaGlobal), U16(1), U16(257),
+ /* 1315 S> */ B(Return),
]
constant pool: [
"name",
diff --git a/test/cctest/interpreter/bytecode_expectations/LogicalExpressions.golden b/test/cctest/interpreter/bytecode_expectations/LogicalExpressions.golden
index cddb9a1..fed8367 100644
--- a/test/cctest/interpreter/bytecode_expectations/LogicalExpressions.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LogicalExpressions.golden
@@ -15,12 +15,12 @@
parameter count: 1
bytecode array length: 9
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(JumpIfToBooleanTrue), U8(4),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanTrue), U8(4),
+ B(LdaSmi), U8(3),
+ /* 60 S> */ B(Return),
]
constant pool: [
]
@@ -35,15 +35,15 @@
parameter count: 1
bytecode array length: 15
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(TestEqual), R(1),
- B(JumpIfTrue), U8(4),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 55 E> */ B(TestEqual), R(1),
+ B(JumpIfTrue), U8(4),
+ B(LdaSmi), U8(3),
+ /* 67 S> */ B(Return),
]
constant pool: [
]
@@ -58,12 +58,12 @@
parameter count: 1
bytecode array length: 9
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(JumpIfToBooleanFalse), U8(4),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanFalse), U8(4),
+ B(LdaSmi), U8(3),
+ /* 60 S> */ B(Return),
]
constant pool: [
]
@@ -78,15 +78,15 @@
parameter count: 1
bytecode array length: 14
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaZero),
- B(TestEqual), R(1),
- B(JumpIfFalse), U8(4),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaZero),
+ /* 55 E> */ B(TestEqual), R(1),
+ B(JumpIfFalse), U8(4),
+ B(LdaSmi), U8(3),
+ /* 67 S> */ B(Return),
]
constant pool: [
]
@@ -101,12 +101,12 @@
parameter count: 1
bytecode array length: 9
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(JumpIfToBooleanTrue), U8(4),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanTrue), U8(4),
+ B(LdaSmi), U8(3),
+ /* 68 S> */ B(Return),
]
constant pool: [
]
@@ -119,25 +119,21 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 32
+bytecode array length: 24
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(2),
- B(Star), R(0),
- B(LdaSmi), U8(3),
- B(Star), R(1),
- B(LdaSmi), U8(4),
- B(Star), R(2),
- B(Ldar), R(0),
- B(JumpIfToBooleanTrue), U8(16),
- B(Ldar), R(0),
- B(Ldar), R(1),
- B(Ldar), R(0),
- B(Ldar), R(1),
- B(LdaSmi), U8(5),
- B(Star), R(2),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(2),
+ /* 42 E> */ B(Star), R(0),
+ /* 49 S> */ B(LdaSmi), U8(3),
+ /* 49 E> */ B(Star), R(1),
+ /* 56 S> */ B(LdaSmi), U8(4),
+ /* 56 E> */ B(Star), R(2),
+ /* 59 S> */ B(Ldar), R(0),
+ B(JumpIfToBooleanTrue), U8(8),
+ /* 81 E> */ B(LdaSmi), U8(5),
+ /* 86 E> */ B(Star), R(2),
+ B(LdaSmi), U8(3),
+ /* 95 S> */ B(Return),
]
constant pool: [
]
@@ -184,145 +180,145 @@
parameter count: 1
bytecode array length: 276
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Star), R(2),
- B(Ldar), R(0),
- B(JumpIfToBooleanTrueConstant), U8(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 53 S> */ B(LdaSmi), U8(2),
+ /* 53 E> */ B(Star), R(1),
+ /* 60 S> */ B(LdaSmi), U8(3),
+ /* 60 E> */ B(Star), R(2),
+ /* 63 S> */ B(Ldar), R(0),
+ B(JumpIfToBooleanTrueConstant), U8(0),
+ B(LdaSmi), U8(1),
+ /* 81 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 88 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 98 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 105 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 115 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 122 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 132 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 139 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 149 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 156 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 166 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 173 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 183 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 190 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 200 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 207 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 217 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 224 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 234 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 241 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 251 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 258 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 268 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 275 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 285 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 292 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 302 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 309 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 319 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 326 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 336 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 343 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 353 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 360 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 370 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 377 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 387 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 394 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 404 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 411 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 421 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 428 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 438 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 445 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 455 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 462 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 472 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 479 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 489 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 496 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 506 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 513 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 523 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 530 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 540 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 547 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 557 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 564 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 574 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 581 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 591 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 598 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 608 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 615 E> */ B(Star), R(2),
+ B(LdaSmi), U8(3),
+ /* 624 S> */ B(Return),
]
constant pool: [
260,
@@ -370,145 +366,145 @@
parameter count: 1
bytecode array length: 275
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Star), R(2),
- B(Ldar), R(0),
- B(JumpIfToBooleanFalseConstant), U8(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 53 S> */ B(LdaSmi), U8(2),
+ /* 53 E> */ B(Star), R(1),
+ /* 60 S> */ B(LdaSmi), U8(3),
+ /* 60 E> */ B(Star), R(2),
+ /* 63 S> */ B(Ldar), R(0),
+ B(JumpIfToBooleanFalseConstant), U8(0),
+ B(LdaSmi), U8(1),
+ /* 81 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 88 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 98 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 105 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 115 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 122 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 132 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 139 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 149 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 156 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 166 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 173 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 183 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 190 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 200 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 207 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 217 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 224 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 234 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 241 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 251 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 258 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 268 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 275 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 285 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 292 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 302 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 309 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 319 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 326 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 336 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 343 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 353 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 360 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 370 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 377 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 387 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 394 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 404 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 411 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 421 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 428 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 438 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 445 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 455 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 462 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 472 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 479 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 489 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 496 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 506 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 513 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 523 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 530 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 540 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 547 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 557 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 564 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 574 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 581 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 591 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 598 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 608 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 615 E> */ B(Star), R(2),
+ B(LdaSmi), U8(3),
+ /* 624 S> */ B(Return),
]
constant pool: [
260,
@@ -556,148 +552,148 @@
parameter count: 1
bytecode array length: 282
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Star), R(2),
- B(Ldar), R(0),
- B(Star), R(3),
- B(LdaSmi), U8(3),
- B(TestGreaterThan), R(3),
- B(JumpIfTrueConstant), U8(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 53 S> */ B(LdaSmi), U8(2),
+ /* 53 E> */ B(Star), R(1),
+ /* 60 S> */ B(LdaSmi), U8(3),
+ /* 60 E> */ B(Star), R(2),
+ /* 63 S> */ B(Ldar), R(0),
+ B(Star), R(3),
+ B(LdaSmi), U8(3),
+ /* 73 E> */ B(TestGreaterThan), R(3),
+ B(JumpIfTrueConstant), U8(0),
+ B(LdaSmi), U8(1),
+ /* 87 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 94 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 104 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 111 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 121 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 128 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 138 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 145 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 155 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 162 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 172 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 179 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 189 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 196 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 206 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 213 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 223 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 230 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 240 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 247 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 257 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 264 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 274 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 281 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 291 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 298 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 308 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 315 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 325 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 332 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 342 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 349 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 359 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 366 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 376 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 383 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 393 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 400 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 410 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 417 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 427 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 434 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 444 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 451 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 461 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 468 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 478 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 485 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 495 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 502 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 512 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 519 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 529 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 536 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 546 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 553 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 563 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 570 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 580 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 587 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 597 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 604 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 614 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 621 E> */ B(Star), R(2),
+ B(LdaSmi), U8(3),
+ /* 630 S> */ B(Return),
]
constant pool: [
260,
@@ -745,148 +741,148 @@
parameter count: 1
bytecode array length: 281
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Star), R(2),
- B(Ldar), R(0),
- B(Star), R(3),
- B(LdaSmi), U8(5),
- B(TestLessThan), R(3),
- B(JumpIfFalseConstant), U8(0),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 53 S> */ B(LdaSmi), U8(2),
+ /* 53 E> */ B(Star), R(1),
+ /* 60 S> */ B(LdaSmi), U8(3),
+ /* 60 E> */ B(Star), R(2),
+ /* 63 S> */ B(Ldar), R(0),
+ B(Star), R(3),
+ B(LdaSmi), U8(5),
+ /* 73 E> */ B(TestLessThan), R(3),
+ B(JumpIfFalseConstant), U8(0),
+ B(LdaSmi), U8(1),
+ /* 87 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 94 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 104 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 111 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 121 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 128 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 138 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 145 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 155 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 162 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 172 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 179 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 189 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 196 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 206 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 213 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 223 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 230 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 240 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 247 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 257 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 264 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 274 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 281 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 291 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 298 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 308 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 315 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 325 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 332 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 342 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 349 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 359 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 366 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 376 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 383 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 393 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 400 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 410 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 417 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 427 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 434 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 444 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 451 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 461 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 468 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 478 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 485 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 495 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 502 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 512 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 519 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 529 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 536 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 546 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 553 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 563 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 570 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 580 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 587 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 597 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 604 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ /* 614 E> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 621 E> */ B(Star), R(2),
+ B(LdaSmi), U8(3),
+ /* 630 S> */ B(Return),
]
constant pool: [
260,
@@ -902,9 +898,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaZero),
+ /* 49 S> */ B(Return),
]
constant pool: [
]
@@ -919,9 +915,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaSmi), U8(1),
+ /* 49 S> */ B(Return),
]
constant pool: [
]
@@ -936,15 +932,15 @@
parameter count: 1
bytecode array length: 15
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(JumpIfToBooleanFalse), U8(4),
- B(LdaSmi), U8(3),
- B(JumpIfToBooleanTrue), U8(3),
- B(LdaZero),
- B(LdaSmi), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanFalse), U8(4),
+ B(LdaSmi), U8(3),
+ B(JumpIfToBooleanTrue), U8(3),
+ B(LdaZero),
+ B(LdaSmi), U8(1),
+ /* 68 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/LookupSlot.golden b/test/cctest/interpreter/bytecode_expectations/LookupSlot.golden
index acec42f..99a78be 100644
--- a/test/cctest/interpreter/bytecode_expectations/LookupSlot.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LookupSlot.golden
@@ -11,36 +11,38 @@
snippet: "
eval('var x = 10;'); return x;
"
-frame size: 9
+frame size: 10
parameter count: 1
-bytecode array length: 67
+bytecode array length: 71
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(Ldar), R(this),
- B(StaContextSlot), R(context), U8(4),
- B(CreateMappedArguments),
- B(StaContextSlot), R(context), U8(5),
- B(Ldar), R(new_target),
- B(StaContextSlot), R(context), U8(6),
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(3),
- B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(Mov), R(1), R(4),
- B(Mov), R(3), R(5),
- B(Mov), R(closure), R(6),
- B(LdaZero),
- B(Star), R(7),
- B(LdaSmi), U8(30),
- B(Star), R(8),
- B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), U8(5),
- B(Star), R(1),
- B(Call), R(1), R(2), U8(2), U8(0),
- B(LdaLookupSlot), U8(2),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(this),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateMappedArguments),
+ B(StaContextSlot), R(context), U8(5),
+ B(Ldar), R(new_target),
+ B(StaContextSlot), R(context), U8(6),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaConstant), U8(0),
+ B(Star), R(3),
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
+ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(Mov), R(1), R(4),
+ B(Mov), R(3), R(5),
+ B(Mov), R(closure), R(6),
+ B(LdaZero),
+ B(Star), R(7),
+ B(LdaSmi), U8(30),
+ B(Star), R(8),
+ B(LdaSmi), U8(34),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), U8(6),
+ B(Star), R(1),
+ /* 34 E> */ B(Call), R(1), R(2), U8(2), U8(0),
+ /* 55 S> */ B(LdaLookupSlot), U8(2),
+ /* 65 S> */ B(Return),
]
constant pool: [
"eval",
@@ -54,37 +56,39 @@
snippet: "
eval('var x = 10;'); return typeof x;
"
-frame size: 9
+frame size: 10
parameter count: 1
-bytecode array length: 68
+bytecode array length: 72
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(Ldar), R(this),
- B(StaContextSlot), R(context), U8(4),
- B(CreateMappedArguments),
- B(StaContextSlot), R(context), U8(5),
- B(Ldar), R(new_target),
- B(StaContextSlot), R(context), U8(6),
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(3),
- B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(Mov), R(1), R(4),
- B(Mov), R(3), R(5),
- B(Mov), R(closure), R(6),
- B(LdaZero),
- B(Star), R(7),
- B(LdaSmi), U8(30),
- B(Star), R(8),
- B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), U8(5),
- B(Star), R(1),
- B(Call), R(1), R(2), U8(2), U8(0),
- B(LdaLookupSlotInsideTypeof), U8(2),
- B(TypeOf),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(this),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateMappedArguments),
+ B(StaContextSlot), R(context), U8(5),
+ B(Ldar), R(new_target),
+ B(StaContextSlot), R(context), U8(6),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaConstant), U8(0),
+ B(Star), R(3),
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
+ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(Mov), R(1), R(4),
+ B(Mov), R(3), R(5),
+ B(Mov), R(closure), R(6),
+ B(LdaZero),
+ B(Star), R(7),
+ B(LdaSmi), U8(30),
+ B(Star), R(8),
+ B(LdaSmi), U8(34),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), U8(6),
+ B(Star), R(1),
+ /* 34 E> */ B(Call), R(1), R(2), U8(2), U8(0),
+ /* 55 S> */ B(LdaLookupSlotInsideTypeof), U8(2),
+ B(TypeOf),
+ /* 72 S> */ B(Return),
]
constant pool: [
"eval",
@@ -98,37 +102,39 @@
snippet: "
x = 20; return eval('');
"
-frame size: 9
+frame size: 10
parameter count: 1
-bytecode array length: 69
+bytecode array length: 73
bytecodes: [
- B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
- B(PushContext), R(0),
- B(Ldar), R(this),
- B(StaContextSlot), R(context), U8(4),
- B(CreateMappedArguments),
- B(StaContextSlot), R(context), U8(5),
- B(Ldar), R(new_target),
- B(StaContextSlot), R(context), U8(6),
- B(StackCheck),
- B(LdaSmi), U8(20),
- B(StaLookupSlotSloppy), U8(0),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
- B(LdaConstant), U8(2),
- B(Star), R(3),
- B(Mov), R(1), R(4),
- B(Mov), R(3), R(5),
- B(Mov), R(closure), R(6),
- B(LdaZero),
- B(Star), R(7),
- B(LdaSmi), U8(30),
- B(Star), R(8),
- B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), U8(5),
- B(Star), R(1),
- B(Call), R(1), R(2), U8(2), U8(0),
- B(Return),
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(0),
+ B(Ldar), R(this),
+ B(StaContextSlot), R(context), U8(4),
+ B(CreateMappedArguments),
+ B(StaContextSlot), R(context), U8(5),
+ B(Ldar), R(new_target),
+ B(StaContextSlot), R(context), U8(6),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaSmi), U8(20),
+ /* 36 E> */ B(StaLookupSlotSloppy), U8(0),
+ /* 42 S> */ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall), R(3), U8(1), R(1),
+ B(LdaConstant), U8(2),
+ B(Star), R(3),
+ B(Mov), R(1), R(4),
+ B(Mov), R(3), R(5),
+ B(Mov), R(closure), R(6),
+ B(LdaZero),
+ B(Star), R(7),
+ B(LdaSmi), U8(30),
+ B(Star), R(8),
+ B(LdaSmi), U8(49),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), U8(6),
+ B(Star), R(1),
+ /* 49 E> */ B(Call), R(1), R(2), U8(2), U8(0),
+ /* 59 S> */ B(Return),
]
constant pool: [
"x",
diff --git a/test/cctest/interpreter/bytecode_expectations/LookupSlotInEval.golden b/test/cctest/interpreter/bytecode_expectations/LookupSlotInEval.golden
index 26e11e3..4147631 100644
--- a/test/cctest/interpreter/bytecode_expectations/LookupSlotInEval.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LookupSlotInEval.golden
@@ -21,9 +21,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaLookupSlot), U8(0),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(LdaLookupSlot), U8(0),
+ /* 25 S> */ B(Return),
]
constant pool: [
"x",
@@ -44,11 +44,11 @@
parameter count: 1
bytecode array length: 7
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(StaLookupSlotSloppy), U8(0),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(LdaSmi), U8(10),
+ /* 17 E> */ B(StaLookupSlotSloppy), U8(0),
+ B(LdaUndefined),
+ /* 23 S> */ B(Return),
]
constant pool: [
"x",
@@ -69,11 +69,11 @@
parameter count: 1
bytecode array length: 7
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(StaLookupSlotStrict), U8(0),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 29 S> */ B(LdaSmi), U8(10),
+ /* 31 E> */ B(StaLookupSlotStrict), U8(0),
+ B(LdaUndefined),
+ /* 37 S> */ B(Return),
]
constant pool: [
"x",
@@ -94,10 +94,10 @@
parameter count: 1
bytecode array length: 5
bytecodes: [
- B(StackCheck),
- B(LdaLookupSlotInsideTypeof), U8(0),
- B(TypeOf),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(LdaLookupSlotInsideTypeof), U8(0),
+ B(TypeOf),
+ /* 32 S> */ B(Return),
]
constant pool: [
"x",
diff --git a/test/cctest/interpreter/bytecode_expectations/LookupSlotWideInEval.golden b/test/cctest/interpreter/bytecode_expectations/LookupSlotWideInEval.golden
index 2fdc3e9..2d493bc 100644
--- a/test/cctest/interpreter/bytecode_expectations/LookupSlotWideInEval.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LookupSlotWideInEval.golden
@@ -281,521 +281,521 @@
parameter count: 1
bytecode array length: 1030
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(2),
- B(Star), R(0),
- B(LdaConstant), U8(3),
- B(Star), R(0),
- B(LdaConstant), U8(4),
- B(Star), R(0),
- B(LdaConstant), U8(5),
- B(Star), R(0),
- B(LdaConstant), U8(6),
- B(Star), R(0),
- B(LdaConstant), U8(7),
- B(Star), R(0),
- B(LdaConstant), U8(8),
- B(Star), R(0),
- B(LdaConstant), U8(9),
- B(Star), R(0),
- B(LdaConstant), U8(10),
- B(Star), R(0),
- B(LdaConstant), U8(11),
- B(Star), R(0),
- B(LdaConstant), U8(12),
- B(Star), R(0),
- B(LdaConstant), U8(13),
- B(Star), R(0),
- B(LdaConstant), U8(14),
- B(Star), R(0),
- B(LdaConstant), U8(15),
- B(Star), R(0),
- B(LdaConstant), U8(16),
- B(Star), R(0),
- B(LdaConstant), U8(17),
- B(Star), R(0),
- B(LdaConstant), U8(18),
- B(Star), R(0),
- B(LdaConstant), U8(19),
- B(Star), R(0),
- B(LdaConstant), U8(20),
- B(Star), R(0),
- B(LdaConstant), U8(21),
- B(Star), R(0),
- B(LdaConstant), U8(22),
- B(Star), R(0),
- B(LdaConstant), U8(23),
- B(Star), R(0),
- B(LdaConstant), U8(24),
- B(Star), R(0),
- B(LdaConstant), U8(25),
- B(Star), R(0),
- B(LdaConstant), U8(26),
- B(Star), R(0),
- B(LdaConstant), U8(27),
- B(Star), R(0),
- B(LdaConstant), U8(28),
- B(Star), R(0),
- B(LdaConstant), U8(29),
- B(Star), R(0),
- B(LdaConstant), U8(30),
- B(Star), R(0),
- B(LdaConstant), U8(31),
- B(Star), R(0),
- B(LdaConstant), U8(32),
- B(Star), R(0),
- B(LdaConstant), U8(33),
- B(Star), R(0),
- B(LdaConstant), U8(34),
- B(Star), R(0),
- B(LdaConstant), U8(35),
- B(Star), R(0),
- B(LdaConstant), U8(36),
- B(Star), R(0),
- B(LdaConstant), U8(37),
- B(Star), R(0),
- B(LdaConstant), U8(38),
- B(Star), R(0),
- B(LdaConstant), U8(39),
- B(Star), R(0),
- B(LdaConstant), U8(40),
- B(Star), R(0),
- B(LdaConstant), U8(41),
- B(Star), R(0),
- B(LdaConstant), U8(42),
- B(Star), R(0),
- B(LdaConstant), U8(43),
- B(Star), R(0),
- B(LdaConstant), U8(44),
- B(Star), R(0),
- B(LdaConstant), U8(45),
- B(Star), R(0),
- B(LdaConstant), U8(46),
- B(Star), R(0),
- B(LdaConstant), U8(47),
- B(Star), R(0),
- B(LdaConstant), U8(48),
- B(Star), R(0),
- B(LdaConstant), U8(49),
- B(Star), R(0),
- B(LdaConstant), U8(50),
- B(Star), R(0),
- B(LdaConstant), U8(51),
- B(Star), R(0),
- B(LdaConstant), U8(52),
- B(Star), R(0),
- B(LdaConstant), U8(53),
- B(Star), R(0),
- B(LdaConstant), U8(54),
- B(Star), R(0),
- B(LdaConstant), U8(55),
- B(Star), R(0),
- B(LdaConstant), U8(56),
- B(Star), R(0),
- B(LdaConstant), U8(57),
- B(Star), R(0),
- B(LdaConstant), U8(58),
- B(Star), R(0),
- B(LdaConstant), U8(59),
- B(Star), R(0),
- B(LdaConstant), U8(60),
- B(Star), R(0),
- B(LdaConstant), U8(61),
- B(Star), R(0),
- B(LdaConstant), U8(62),
- B(Star), R(0),
- B(LdaConstant), U8(63),
- B(Star), R(0),
- B(LdaConstant), U8(64),
- B(Star), R(0),
- B(LdaConstant), U8(65),
- B(Star), R(0),
- B(LdaConstant), U8(66),
- B(Star), R(0),
- B(LdaConstant), U8(67),
- B(Star), R(0),
- B(LdaConstant), U8(68),
- B(Star), R(0),
- B(LdaConstant), U8(69),
- B(Star), R(0),
- B(LdaConstant), U8(70),
- B(Star), R(0),
- B(LdaConstant), U8(71),
- B(Star), R(0),
- B(LdaConstant), U8(72),
- B(Star), R(0),
- B(LdaConstant), U8(73),
- B(Star), R(0),
- B(LdaConstant), U8(74),
- B(Star), R(0),
- B(LdaConstant), U8(75),
- B(Star), R(0),
- B(LdaConstant), U8(76),
- B(Star), R(0),
- B(LdaConstant), U8(77),
- B(Star), R(0),
- B(LdaConstant), U8(78),
- B(Star), R(0),
- B(LdaConstant), U8(79),
- B(Star), R(0),
- B(LdaConstant), U8(80),
- B(Star), R(0),
- B(LdaConstant), U8(81),
- B(Star), R(0),
- B(LdaConstant), U8(82),
- B(Star), R(0),
- B(LdaConstant), U8(83),
- B(Star), R(0),
- B(LdaConstant), U8(84),
- B(Star), R(0),
- B(LdaConstant), U8(85),
- B(Star), R(0),
- B(LdaConstant), U8(86),
- B(Star), R(0),
- B(LdaConstant), U8(87),
- B(Star), R(0),
- B(LdaConstant), U8(88),
- B(Star), R(0),
- B(LdaConstant), U8(89),
- B(Star), R(0),
- B(LdaConstant), U8(90),
- B(Star), R(0),
- B(LdaConstant), U8(91),
- B(Star), R(0),
- B(LdaConstant), U8(92),
- B(Star), R(0),
- B(LdaConstant), U8(93),
- B(Star), R(0),
- B(LdaConstant), U8(94),
- B(Star), R(0),
- B(LdaConstant), U8(95),
- B(Star), R(0),
- B(LdaConstant), U8(96),
- B(Star), R(0),
- B(LdaConstant), U8(97),
- B(Star), R(0),
- B(LdaConstant), U8(98),
- B(Star), R(0),
- B(LdaConstant), U8(99),
- B(Star), R(0),
- B(LdaConstant), U8(100),
- B(Star), R(0),
- B(LdaConstant), U8(101),
- B(Star), R(0),
- B(LdaConstant), U8(102),
- B(Star), R(0),
- B(LdaConstant), U8(103),
- B(Star), R(0),
- B(LdaConstant), U8(104),
- B(Star), R(0),
- B(LdaConstant), U8(105),
- B(Star), R(0),
- B(LdaConstant), U8(106),
- B(Star), R(0),
- B(LdaConstant), U8(107),
- B(Star), R(0),
- B(LdaConstant), U8(108),
- B(Star), R(0),
- B(LdaConstant), U8(109),
- B(Star), R(0),
- B(LdaConstant), U8(110),
- B(Star), R(0),
- B(LdaConstant), U8(111),
- B(Star), R(0),
- B(LdaConstant), U8(112),
- B(Star), R(0),
- B(LdaConstant), U8(113),
- B(Star), R(0),
- B(LdaConstant), U8(114),
- B(Star), R(0),
- B(LdaConstant), U8(115),
- B(Star), R(0),
- B(LdaConstant), U8(116),
- B(Star), R(0),
- B(LdaConstant), U8(117),
- B(Star), R(0),
- B(LdaConstant), U8(118),
- B(Star), R(0),
- B(LdaConstant), U8(119),
- B(Star), R(0),
- B(LdaConstant), U8(120),
- B(Star), R(0),
- B(LdaConstant), U8(121),
- B(Star), R(0),
- B(LdaConstant), U8(122),
- B(Star), R(0),
- B(LdaConstant), U8(123),
- B(Star), R(0),
- B(LdaConstant), U8(124),
- B(Star), R(0),
- B(LdaConstant), U8(125),
- B(Star), R(0),
- B(LdaConstant), U8(126),
- B(Star), R(0),
- B(LdaConstant), U8(127),
- B(Star), R(0),
- B(LdaConstant), U8(128),
- B(Star), R(0),
- B(LdaConstant), U8(129),
- B(Star), R(0),
- B(LdaConstant), U8(130),
- B(Star), R(0),
- B(LdaConstant), U8(131),
- B(Star), R(0),
- B(LdaConstant), U8(132),
- B(Star), R(0),
- B(LdaConstant), U8(133),
- B(Star), R(0),
- B(LdaConstant), U8(134),
- B(Star), R(0),
- B(LdaConstant), U8(135),
- B(Star), R(0),
- B(LdaConstant), U8(136),
- B(Star), R(0),
- B(LdaConstant), U8(137),
- B(Star), R(0),
- B(LdaConstant), U8(138),
- B(Star), R(0),
- B(LdaConstant), U8(139),
- B(Star), R(0),
- B(LdaConstant), U8(140),
- B(Star), R(0),
- B(LdaConstant), U8(141),
- B(Star), R(0),
- B(LdaConstant), U8(142),
- B(Star), R(0),
- B(LdaConstant), U8(143),
- B(Star), R(0),
- B(LdaConstant), U8(144),
- B(Star), R(0),
- B(LdaConstant), U8(145),
- B(Star), R(0),
- B(LdaConstant), U8(146),
- B(Star), R(0),
- B(LdaConstant), U8(147),
- B(Star), R(0),
- B(LdaConstant), U8(148),
- B(Star), R(0),
- B(LdaConstant), U8(149),
- B(Star), R(0),
- B(LdaConstant), U8(150),
- B(Star), R(0),
- B(LdaConstant), U8(151),
- B(Star), R(0),
- B(LdaConstant), U8(152),
- B(Star), R(0),
- B(LdaConstant), U8(153),
- B(Star), R(0),
- B(LdaConstant), U8(154),
- B(Star), R(0),
- B(LdaConstant), U8(155),
- B(Star), R(0),
- B(LdaConstant), U8(156),
- B(Star), R(0),
- B(LdaConstant), U8(157),
- B(Star), R(0),
- B(LdaConstant), U8(158),
- B(Star), R(0),
- B(LdaConstant), U8(159),
- B(Star), R(0),
- B(LdaConstant), U8(160),
- B(Star), R(0),
- B(LdaConstant), U8(161),
- B(Star), R(0),
- B(LdaConstant), U8(162),
- B(Star), R(0),
- B(LdaConstant), U8(163),
- B(Star), R(0),
- B(LdaConstant), U8(164),
- B(Star), R(0),
- B(LdaConstant), U8(165),
- B(Star), R(0),
- B(LdaConstant), U8(166),
- B(Star), R(0),
- B(LdaConstant), U8(167),
- B(Star), R(0),
- B(LdaConstant), U8(168),
- B(Star), R(0),
- B(LdaConstant), U8(169),
- B(Star), R(0),
- B(LdaConstant), U8(170),
- B(Star), R(0),
- B(LdaConstant), U8(171),
- B(Star), R(0),
- B(LdaConstant), U8(172),
- B(Star), R(0),
- B(LdaConstant), U8(173),
- B(Star), R(0),
- B(LdaConstant), U8(174),
- B(Star), R(0),
- B(LdaConstant), U8(175),
- B(Star), R(0),
- B(LdaConstant), U8(176),
- B(Star), R(0),
- B(LdaConstant), U8(177),
- B(Star), R(0),
- B(LdaConstant), U8(178),
- B(Star), R(0),
- B(LdaConstant), U8(179),
- B(Star), R(0),
- B(LdaConstant), U8(180),
- B(Star), R(0),
- B(LdaConstant), U8(181),
- B(Star), R(0),
- B(LdaConstant), U8(182),
- B(Star), R(0),
- B(LdaConstant), U8(183),
- B(Star), R(0),
- B(LdaConstant), U8(184),
- B(Star), R(0),
- B(LdaConstant), U8(185),
- B(Star), R(0),
- B(LdaConstant), U8(186),
- B(Star), R(0),
- B(LdaConstant), U8(187),
- B(Star), R(0),
- B(LdaConstant), U8(188),
- B(Star), R(0),
- B(LdaConstant), U8(189),
- B(Star), R(0),
- B(LdaConstant), U8(190),
- B(Star), R(0),
- B(LdaConstant), U8(191),
- B(Star), R(0),
- B(LdaConstant), U8(192),
- B(Star), R(0),
- B(LdaConstant), U8(193),
- B(Star), R(0),
- B(LdaConstant), U8(194),
- B(Star), R(0),
- B(LdaConstant), U8(195),
- B(Star), R(0),
- B(LdaConstant), U8(196),
- B(Star), R(0),
- B(LdaConstant), U8(197),
- B(Star), R(0),
- B(LdaConstant), U8(198),
- B(Star), R(0),
- B(LdaConstant), U8(199),
- B(Star), R(0),
- B(LdaConstant), U8(200),
- B(Star), R(0),
- B(LdaConstant), U8(201),
- B(Star), R(0),
- B(LdaConstant), U8(202),
- B(Star), R(0),
- B(LdaConstant), U8(203),
- B(Star), R(0),
- B(LdaConstant), U8(204),
- B(Star), R(0),
- B(LdaConstant), U8(205),
- B(Star), R(0),
- B(LdaConstant), U8(206),
- B(Star), R(0),
- B(LdaConstant), U8(207),
- B(Star), R(0),
- B(LdaConstant), U8(208),
- B(Star), R(0),
- B(LdaConstant), U8(209),
- B(Star), R(0),
- B(LdaConstant), U8(210),
- B(Star), R(0),
- B(LdaConstant), U8(211),
- B(Star), R(0),
- B(LdaConstant), U8(212),
- B(Star), R(0),
- B(LdaConstant), U8(213),
- B(Star), R(0),
- B(LdaConstant), U8(214),
- B(Star), R(0),
- B(LdaConstant), U8(215),
- B(Star), R(0),
- B(LdaConstant), U8(216),
- B(Star), R(0),
- B(LdaConstant), U8(217),
- B(Star), R(0),
- B(LdaConstant), U8(218),
- B(Star), R(0),
- B(LdaConstant), U8(219),
- B(Star), R(0),
- B(LdaConstant), U8(220),
- B(Star), R(0),
- B(LdaConstant), U8(221),
- B(Star), R(0),
- B(LdaConstant), U8(222),
- B(Star), R(0),
- B(LdaConstant), U8(223),
- B(Star), R(0),
- B(LdaConstant), U8(224),
- B(Star), R(0),
- B(LdaConstant), U8(225),
- B(Star), R(0),
- B(LdaConstant), U8(226),
- B(Star), R(0),
- B(LdaConstant), U8(227),
- B(Star), R(0),
- B(LdaConstant), U8(228),
- B(Star), R(0),
- B(LdaConstant), U8(229),
- B(Star), R(0),
- B(LdaConstant), U8(230),
- B(Star), R(0),
- B(LdaConstant), U8(231),
- B(Star), R(0),
- B(LdaConstant), U8(232),
- B(Star), R(0),
- B(LdaConstant), U8(233),
- B(Star), R(0),
- B(LdaConstant), U8(234),
- B(Star), R(0),
- B(LdaConstant), U8(235),
- B(Star), R(0),
- B(LdaConstant), U8(236),
- B(Star), R(0),
- B(LdaConstant), U8(237),
- B(Star), R(0),
- B(LdaConstant), U8(238),
- B(Star), R(0),
- B(LdaConstant), U8(239),
- B(Star), R(0),
- B(LdaConstant), U8(240),
- B(Star), R(0),
- B(LdaConstant), U8(241),
- B(Star), R(0),
- B(LdaConstant), U8(242),
- B(Star), R(0),
- B(LdaConstant), U8(243),
- B(Star), R(0),
- B(LdaConstant), U8(244),
- B(Star), R(0),
- B(LdaConstant), U8(245),
- B(Star), R(0),
- B(LdaConstant), U8(246),
- B(Star), R(0),
- B(LdaConstant), U8(247),
- B(Star), R(0),
- B(LdaConstant), U8(248),
- B(Star), R(0),
- B(LdaConstant), U8(249),
- B(Star), R(0),
- B(LdaConstant), U8(250),
- B(Star), R(0),
- B(LdaConstant), U8(251),
- B(Star), R(0),
- B(LdaConstant), U8(252),
- B(Star), R(0),
- B(LdaConstant), U8(253),
- B(Star), R(0),
- B(LdaConstant), U8(254),
- B(Star), R(0),
- B(LdaConstant), U8(255),
- B(Star), R(0),
- B(Wide), B(LdaLookupSlot), U16(256),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 22 S> */ B(LdaConstant), U8(0),
+ /* 22 E> */ B(Star), R(0),
+ /* 34 S> */ B(LdaConstant), U8(1),
+ /* 34 E> */ B(Star), R(0),
+ /* 46 S> */ B(LdaConstant), U8(2),
+ /* 46 E> */ B(Star), R(0),
+ /* 58 S> */ B(LdaConstant), U8(3),
+ /* 58 E> */ B(Star), R(0),
+ /* 70 S> */ B(LdaConstant), U8(4),
+ /* 70 E> */ B(Star), R(0),
+ /* 82 S> */ B(LdaConstant), U8(5),
+ /* 82 E> */ B(Star), R(0),
+ /* 94 S> */ B(LdaConstant), U8(6),
+ /* 94 E> */ B(Star), R(0),
+ /* 106 S> */ B(LdaConstant), U8(7),
+ /* 106 E> */ B(Star), R(0),
+ /* 118 S> */ B(LdaConstant), U8(8),
+ /* 118 E> */ B(Star), R(0),
+ /* 130 S> */ B(LdaConstant), U8(9),
+ /* 130 E> */ B(Star), R(0),
+ /* 142 S> */ B(LdaConstant), U8(10),
+ /* 142 E> */ B(Star), R(0),
+ /* 154 S> */ B(LdaConstant), U8(11),
+ /* 154 E> */ B(Star), R(0),
+ /* 166 S> */ B(LdaConstant), U8(12),
+ /* 166 E> */ B(Star), R(0),
+ /* 178 S> */ B(LdaConstant), U8(13),
+ /* 178 E> */ B(Star), R(0),
+ /* 190 S> */ B(LdaConstant), U8(14),
+ /* 190 E> */ B(Star), R(0),
+ /* 202 S> */ B(LdaConstant), U8(15),
+ /* 202 E> */ B(Star), R(0),
+ /* 214 S> */ B(LdaConstant), U8(16),
+ /* 214 E> */ B(Star), R(0),
+ /* 226 S> */ B(LdaConstant), U8(17),
+ /* 226 E> */ B(Star), R(0),
+ /* 238 S> */ B(LdaConstant), U8(18),
+ /* 238 E> */ B(Star), R(0),
+ /* 250 S> */ B(LdaConstant), U8(19),
+ /* 250 E> */ B(Star), R(0),
+ /* 262 S> */ B(LdaConstant), U8(20),
+ /* 262 E> */ B(Star), R(0),
+ /* 274 S> */ B(LdaConstant), U8(21),
+ /* 274 E> */ B(Star), R(0),
+ /* 286 S> */ B(LdaConstant), U8(22),
+ /* 286 E> */ B(Star), R(0),
+ /* 298 S> */ B(LdaConstant), U8(23),
+ /* 298 E> */ B(Star), R(0),
+ /* 310 S> */ B(LdaConstant), U8(24),
+ /* 310 E> */ B(Star), R(0),
+ /* 322 S> */ B(LdaConstant), U8(25),
+ /* 322 E> */ B(Star), R(0),
+ /* 334 S> */ B(LdaConstant), U8(26),
+ /* 334 E> */ B(Star), R(0),
+ /* 346 S> */ B(LdaConstant), U8(27),
+ /* 346 E> */ B(Star), R(0),
+ /* 358 S> */ B(LdaConstant), U8(28),
+ /* 358 E> */ B(Star), R(0),
+ /* 370 S> */ B(LdaConstant), U8(29),
+ /* 370 E> */ B(Star), R(0),
+ /* 382 S> */ B(LdaConstant), U8(30),
+ /* 382 E> */ B(Star), R(0),
+ /* 394 S> */ B(LdaConstant), U8(31),
+ /* 394 E> */ B(Star), R(0),
+ /* 406 S> */ B(LdaConstant), U8(32),
+ /* 406 E> */ B(Star), R(0),
+ /* 418 S> */ B(LdaConstant), U8(33),
+ /* 418 E> */ B(Star), R(0),
+ /* 430 S> */ B(LdaConstant), U8(34),
+ /* 430 E> */ B(Star), R(0),
+ /* 442 S> */ B(LdaConstant), U8(35),
+ /* 442 E> */ B(Star), R(0),
+ /* 454 S> */ B(LdaConstant), U8(36),
+ /* 454 E> */ B(Star), R(0),
+ /* 466 S> */ B(LdaConstant), U8(37),
+ /* 466 E> */ B(Star), R(0),
+ /* 478 S> */ B(LdaConstant), U8(38),
+ /* 478 E> */ B(Star), R(0),
+ /* 490 S> */ B(LdaConstant), U8(39),
+ /* 490 E> */ B(Star), R(0),
+ /* 502 S> */ B(LdaConstant), U8(40),
+ /* 502 E> */ B(Star), R(0),
+ /* 514 S> */ B(LdaConstant), U8(41),
+ /* 514 E> */ B(Star), R(0),
+ /* 526 S> */ B(LdaConstant), U8(42),
+ /* 526 E> */ B(Star), R(0),
+ /* 538 S> */ B(LdaConstant), U8(43),
+ /* 538 E> */ B(Star), R(0),
+ /* 550 S> */ B(LdaConstant), U8(44),
+ /* 550 E> */ B(Star), R(0),
+ /* 562 S> */ B(LdaConstant), U8(45),
+ /* 562 E> */ B(Star), R(0),
+ /* 574 S> */ B(LdaConstant), U8(46),
+ /* 574 E> */ B(Star), R(0),
+ /* 586 S> */ B(LdaConstant), U8(47),
+ /* 586 E> */ B(Star), R(0),
+ /* 598 S> */ B(LdaConstant), U8(48),
+ /* 598 E> */ B(Star), R(0),
+ /* 610 S> */ B(LdaConstant), U8(49),
+ /* 610 E> */ B(Star), R(0),
+ /* 622 S> */ B(LdaConstant), U8(50),
+ /* 622 E> */ B(Star), R(0),
+ /* 634 S> */ B(LdaConstant), U8(51),
+ /* 634 E> */ B(Star), R(0),
+ /* 646 S> */ B(LdaConstant), U8(52),
+ /* 646 E> */ B(Star), R(0),
+ /* 658 S> */ B(LdaConstant), U8(53),
+ /* 658 E> */ B(Star), R(0),
+ /* 670 S> */ B(LdaConstant), U8(54),
+ /* 670 E> */ B(Star), R(0),
+ /* 682 S> */ B(LdaConstant), U8(55),
+ /* 682 E> */ B(Star), R(0),
+ /* 694 S> */ B(LdaConstant), U8(56),
+ /* 694 E> */ B(Star), R(0),
+ /* 706 S> */ B(LdaConstant), U8(57),
+ /* 706 E> */ B(Star), R(0),
+ /* 718 S> */ B(LdaConstant), U8(58),
+ /* 718 E> */ B(Star), R(0),
+ /* 730 S> */ B(LdaConstant), U8(59),
+ /* 730 E> */ B(Star), R(0),
+ /* 742 S> */ B(LdaConstant), U8(60),
+ /* 742 E> */ B(Star), R(0),
+ /* 754 S> */ B(LdaConstant), U8(61),
+ /* 754 E> */ B(Star), R(0),
+ /* 766 S> */ B(LdaConstant), U8(62),
+ /* 766 E> */ B(Star), R(0),
+ /* 778 S> */ B(LdaConstant), U8(63),
+ /* 778 E> */ B(Star), R(0),
+ /* 790 S> */ B(LdaConstant), U8(64),
+ /* 790 E> */ B(Star), R(0),
+ /* 802 S> */ B(LdaConstant), U8(65),
+ /* 802 E> */ B(Star), R(0),
+ /* 814 S> */ B(LdaConstant), U8(66),
+ /* 814 E> */ B(Star), R(0),
+ /* 826 S> */ B(LdaConstant), U8(67),
+ /* 826 E> */ B(Star), R(0),
+ /* 838 S> */ B(LdaConstant), U8(68),
+ /* 838 E> */ B(Star), R(0),
+ /* 850 S> */ B(LdaConstant), U8(69),
+ /* 850 E> */ B(Star), R(0),
+ /* 862 S> */ B(LdaConstant), U8(70),
+ /* 862 E> */ B(Star), R(0),
+ /* 874 S> */ B(LdaConstant), U8(71),
+ /* 874 E> */ B(Star), R(0),
+ /* 886 S> */ B(LdaConstant), U8(72),
+ /* 886 E> */ B(Star), R(0),
+ /* 898 S> */ B(LdaConstant), U8(73),
+ /* 898 E> */ B(Star), R(0),
+ /* 910 S> */ B(LdaConstant), U8(74),
+ /* 910 E> */ B(Star), R(0),
+ /* 922 S> */ B(LdaConstant), U8(75),
+ /* 922 E> */ B(Star), R(0),
+ /* 934 S> */ B(LdaConstant), U8(76),
+ /* 934 E> */ B(Star), R(0),
+ /* 946 S> */ B(LdaConstant), U8(77),
+ /* 946 E> */ B(Star), R(0),
+ /* 958 S> */ B(LdaConstant), U8(78),
+ /* 958 E> */ B(Star), R(0),
+ /* 970 S> */ B(LdaConstant), U8(79),
+ /* 970 E> */ B(Star), R(0),
+ /* 982 S> */ B(LdaConstant), U8(80),
+ /* 982 E> */ B(Star), R(0),
+ /* 994 S> */ B(LdaConstant), U8(81),
+ /* 994 E> */ B(Star), R(0),
+ /* 1006 S> */ B(LdaConstant), U8(82),
+ /* 1006 E> */ B(Star), R(0),
+ /* 1018 S> */ B(LdaConstant), U8(83),
+ /* 1018 E> */ B(Star), R(0),
+ /* 1030 S> */ B(LdaConstant), U8(84),
+ /* 1030 E> */ B(Star), R(0),
+ /* 1042 S> */ B(LdaConstant), U8(85),
+ /* 1042 E> */ B(Star), R(0),
+ /* 1054 S> */ B(LdaConstant), U8(86),
+ /* 1054 E> */ B(Star), R(0),
+ /* 1066 S> */ B(LdaConstant), U8(87),
+ /* 1066 E> */ B(Star), R(0),
+ /* 1078 S> */ B(LdaConstant), U8(88),
+ /* 1078 E> */ B(Star), R(0),
+ /* 1090 S> */ B(LdaConstant), U8(89),
+ /* 1090 E> */ B(Star), R(0),
+ /* 1102 S> */ B(LdaConstant), U8(90),
+ /* 1102 E> */ B(Star), R(0),
+ /* 1114 S> */ B(LdaConstant), U8(91),
+ /* 1114 E> */ B(Star), R(0),
+ /* 1126 S> */ B(LdaConstant), U8(92),
+ /* 1126 E> */ B(Star), R(0),
+ /* 1138 S> */ B(LdaConstant), U8(93),
+ /* 1138 E> */ B(Star), R(0),
+ /* 1150 S> */ B(LdaConstant), U8(94),
+ /* 1150 E> */ B(Star), R(0),
+ /* 1162 S> */ B(LdaConstant), U8(95),
+ /* 1162 E> */ B(Star), R(0),
+ /* 1174 S> */ B(LdaConstant), U8(96),
+ /* 1174 E> */ B(Star), R(0),
+ /* 1186 S> */ B(LdaConstant), U8(97),
+ /* 1186 E> */ B(Star), R(0),
+ /* 1198 S> */ B(LdaConstant), U8(98),
+ /* 1198 E> */ B(Star), R(0),
+ /* 1210 S> */ B(LdaConstant), U8(99),
+ /* 1210 E> */ B(Star), R(0),
+ /* 1222 S> */ B(LdaConstant), U8(100),
+ /* 1222 E> */ B(Star), R(0),
+ /* 1234 S> */ B(LdaConstant), U8(101),
+ /* 1234 E> */ B(Star), R(0),
+ /* 1246 S> */ B(LdaConstant), U8(102),
+ /* 1246 E> */ B(Star), R(0),
+ /* 1258 S> */ B(LdaConstant), U8(103),
+ /* 1258 E> */ B(Star), R(0),
+ /* 1270 S> */ B(LdaConstant), U8(104),
+ /* 1270 E> */ B(Star), R(0),
+ /* 1282 S> */ B(LdaConstant), U8(105),
+ /* 1282 E> */ B(Star), R(0),
+ /* 1294 S> */ B(LdaConstant), U8(106),
+ /* 1294 E> */ B(Star), R(0),
+ /* 1306 S> */ B(LdaConstant), U8(107),
+ /* 1306 E> */ B(Star), R(0),
+ /* 1318 S> */ B(LdaConstant), U8(108),
+ /* 1318 E> */ B(Star), R(0),
+ /* 1330 S> */ B(LdaConstant), U8(109),
+ /* 1330 E> */ B(Star), R(0),
+ /* 1342 S> */ B(LdaConstant), U8(110),
+ /* 1342 E> */ B(Star), R(0),
+ /* 1354 S> */ B(LdaConstant), U8(111),
+ /* 1354 E> */ B(Star), R(0),
+ /* 1366 S> */ B(LdaConstant), U8(112),
+ /* 1366 E> */ B(Star), R(0),
+ /* 1378 S> */ B(LdaConstant), U8(113),
+ /* 1378 E> */ B(Star), R(0),
+ /* 1390 S> */ B(LdaConstant), U8(114),
+ /* 1390 E> */ B(Star), R(0),
+ /* 1402 S> */ B(LdaConstant), U8(115),
+ /* 1402 E> */ B(Star), R(0),
+ /* 1414 S> */ B(LdaConstant), U8(116),
+ /* 1414 E> */ B(Star), R(0),
+ /* 1426 S> */ B(LdaConstant), U8(117),
+ /* 1426 E> */ B(Star), R(0),
+ /* 1438 S> */ B(LdaConstant), U8(118),
+ /* 1438 E> */ B(Star), R(0),
+ /* 1450 S> */ B(LdaConstant), U8(119),
+ /* 1450 E> */ B(Star), R(0),
+ /* 1462 S> */ B(LdaConstant), U8(120),
+ /* 1462 E> */ B(Star), R(0),
+ /* 1474 S> */ B(LdaConstant), U8(121),
+ /* 1474 E> */ B(Star), R(0),
+ /* 1486 S> */ B(LdaConstant), U8(122),
+ /* 1486 E> */ B(Star), R(0),
+ /* 1498 S> */ B(LdaConstant), U8(123),
+ /* 1498 E> */ B(Star), R(0),
+ /* 1510 S> */ B(LdaConstant), U8(124),
+ /* 1510 E> */ B(Star), R(0),
+ /* 1522 S> */ B(LdaConstant), U8(125),
+ /* 1522 E> */ B(Star), R(0),
+ /* 1534 S> */ B(LdaConstant), U8(126),
+ /* 1534 E> */ B(Star), R(0),
+ /* 1546 S> */ B(LdaConstant), U8(127),
+ /* 1546 E> */ B(Star), R(0),
+ /* 1558 S> */ B(LdaConstant), U8(128),
+ /* 1558 E> */ B(Star), R(0),
+ /* 1570 S> */ B(LdaConstant), U8(129),
+ /* 1570 E> */ B(Star), R(0),
+ /* 1582 S> */ B(LdaConstant), U8(130),
+ /* 1582 E> */ B(Star), R(0),
+ /* 1594 S> */ B(LdaConstant), U8(131),
+ /* 1594 E> */ B(Star), R(0),
+ /* 1606 S> */ B(LdaConstant), U8(132),
+ /* 1606 E> */ B(Star), R(0),
+ /* 1618 S> */ B(LdaConstant), U8(133),
+ /* 1618 E> */ B(Star), R(0),
+ /* 1630 S> */ B(LdaConstant), U8(134),
+ /* 1630 E> */ B(Star), R(0),
+ /* 1642 S> */ B(LdaConstant), U8(135),
+ /* 1642 E> */ B(Star), R(0),
+ /* 1654 S> */ B(LdaConstant), U8(136),
+ /* 1654 E> */ B(Star), R(0),
+ /* 1666 S> */ B(LdaConstant), U8(137),
+ /* 1666 E> */ B(Star), R(0),
+ /* 1678 S> */ B(LdaConstant), U8(138),
+ /* 1678 E> */ B(Star), R(0),
+ /* 1690 S> */ B(LdaConstant), U8(139),
+ /* 1690 E> */ B(Star), R(0),
+ /* 1702 S> */ B(LdaConstant), U8(140),
+ /* 1702 E> */ B(Star), R(0),
+ /* 1714 S> */ B(LdaConstant), U8(141),
+ /* 1714 E> */ B(Star), R(0),
+ /* 1726 S> */ B(LdaConstant), U8(142),
+ /* 1726 E> */ B(Star), R(0),
+ /* 1738 S> */ B(LdaConstant), U8(143),
+ /* 1738 E> */ B(Star), R(0),
+ /* 1750 S> */ B(LdaConstant), U8(144),
+ /* 1750 E> */ B(Star), R(0),
+ /* 1762 S> */ B(LdaConstant), U8(145),
+ /* 1762 E> */ B(Star), R(0),
+ /* 1774 S> */ B(LdaConstant), U8(146),
+ /* 1774 E> */ B(Star), R(0),
+ /* 1786 S> */ B(LdaConstant), U8(147),
+ /* 1786 E> */ B(Star), R(0),
+ /* 1798 S> */ B(LdaConstant), U8(148),
+ /* 1798 E> */ B(Star), R(0),
+ /* 1810 S> */ B(LdaConstant), U8(149),
+ /* 1810 E> */ B(Star), R(0),
+ /* 1822 S> */ B(LdaConstant), U8(150),
+ /* 1822 E> */ B(Star), R(0),
+ /* 1834 S> */ B(LdaConstant), U8(151),
+ /* 1834 E> */ B(Star), R(0),
+ /* 1846 S> */ B(LdaConstant), U8(152),
+ /* 1846 E> */ B(Star), R(0),
+ /* 1858 S> */ B(LdaConstant), U8(153),
+ /* 1858 E> */ B(Star), R(0),
+ /* 1870 S> */ B(LdaConstant), U8(154),
+ /* 1870 E> */ B(Star), R(0),
+ /* 1882 S> */ B(LdaConstant), U8(155),
+ /* 1882 E> */ B(Star), R(0),
+ /* 1894 S> */ B(LdaConstant), U8(156),
+ /* 1894 E> */ B(Star), R(0),
+ /* 1906 S> */ B(LdaConstant), U8(157),
+ /* 1906 E> */ B(Star), R(0),
+ /* 1918 S> */ B(LdaConstant), U8(158),
+ /* 1918 E> */ B(Star), R(0),
+ /* 1930 S> */ B(LdaConstant), U8(159),
+ /* 1930 E> */ B(Star), R(0),
+ /* 1942 S> */ B(LdaConstant), U8(160),
+ /* 1942 E> */ B(Star), R(0),
+ /* 1954 S> */ B(LdaConstant), U8(161),
+ /* 1954 E> */ B(Star), R(0),
+ /* 1966 S> */ B(LdaConstant), U8(162),
+ /* 1966 E> */ B(Star), R(0),
+ /* 1978 S> */ B(LdaConstant), U8(163),
+ /* 1978 E> */ B(Star), R(0),
+ /* 1990 S> */ B(LdaConstant), U8(164),
+ /* 1990 E> */ B(Star), R(0),
+ /* 2002 S> */ B(LdaConstant), U8(165),
+ /* 2002 E> */ B(Star), R(0),
+ /* 2014 S> */ B(LdaConstant), U8(166),
+ /* 2014 E> */ B(Star), R(0),
+ /* 2026 S> */ B(LdaConstant), U8(167),
+ /* 2026 E> */ B(Star), R(0),
+ /* 2038 S> */ B(LdaConstant), U8(168),
+ /* 2038 E> */ B(Star), R(0),
+ /* 2050 S> */ B(LdaConstant), U8(169),
+ /* 2050 E> */ B(Star), R(0),
+ /* 2062 S> */ B(LdaConstant), U8(170),
+ /* 2062 E> */ B(Star), R(0),
+ /* 2074 S> */ B(LdaConstant), U8(171),
+ /* 2074 E> */ B(Star), R(0),
+ /* 2086 S> */ B(LdaConstant), U8(172),
+ /* 2086 E> */ B(Star), R(0),
+ /* 2098 S> */ B(LdaConstant), U8(173),
+ /* 2098 E> */ B(Star), R(0),
+ /* 2110 S> */ B(LdaConstant), U8(174),
+ /* 2110 E> */ B(Star), R(0),
+ /* 2122 S> */ B(LdaConstant), U8(175),
+ /* 2122 E> */ B(Star), R(0),
+ /* 2134 S> */ B(LdaConstant), U8(176),
+ /* 2134 E> */ B(Star), R(0),
+ /* 2146 S> */ B(LdaConstant), U8(177),
+ /* 2146 E> */ B(Star), R(0),
+ /* 2158 S> */ B(LdaConstant), U8(178),
+ /* 2158 E> */ B(Star), R(0),
+ /* 2170 S> */ B(LdaConstant), U8(179),
+ /* 2170 E> */ B(Star), R(0),
+ /* 2182 S> */ B(LdaConstant), U8(180),
+ /* 2182 E> */ B(Star), R(0),
+ /* 2194 S> */ B(LdaConstant), U8(181),
+ /* 2194 E> */ B(Star), R(0),
+ /* 2206 S> */ B(LdaConstant), U8(182),
+ /* 2206 E> */ B(Star), R(0),
+ /* 2218 S> */ B(LdaConstant), U8(183),
+ /* 2218 E> */ B(Star), R(0),
+ /* 2230 S> */ B(LdaConstant), U8(184),
+ /* 2230 E> */ B(Star), R(0),
+ /* 2242 S> */ B(LdaConstant), U8(185),
+ /* 2242 E> */ B(Star), R(0),
+ /* 2254 S> */ B(LdaConstant), U8(186),
+ /* 2254 E> */ B(Star), R(0),
+ /* 2266 S> */ B(LdaConstant), U8(187),
+ /* 2266 E> */ B(Star), R(0),
+ /* 2278 S> */ B(LdaConstant), U8(188),
+ /* 2278 E> */ B(Star), R(0),
+ /* 2290 S> */ B(LdaConstant), U8(189),
+ /* 2290 E> */ B(Star), R(0),
+ /* 2302 S> */ B(LdaConstant), U8(190),
+ /* 2302 E> */ B(Star), R(0),
+ /* 2314 S> */ B(LdaConstant), U8(191),
+ /* 2314 E> */ B(Star), R(0),
+ /* 2326 S> */ B(LdaConstant), U8(192),
+ /* 2326 E> */ B(Star), R(0),
+ /* 2338 S> */ B(LdaConstant), U8(193),
+ /* 2338 E> */ B(Star), R(0),
+ /* 2350 S> */ B(LdaConstant), U8(194),
+ /* 2350 E> */ B(Star), R(0),
+ /* 2362 S> */ B(LdaConstant), U8(195),
+ /* 2362 E> */ B(Star), R(0),
+ /* 2374 S> */ B(LdaConstant), U8(196),
+ /* 2374 E> */ B(Star), R(0),
+ /* 2386 S> */ B(LdaConstant), U8(197),
+ /* 2386 E> */ B(Star), R(0),
+ /* 2398 S> */ B(LdaConstant), U8(198),
+ /* 2398 E> */ B(Star), R(0),
+ /* 2410 S> */ B(LdaConstant), U8(199),
+ /* 2410 E> */ B(Star), R(0),
+ /* 2422 S> */ B(LdaConstant), U8(200),
+ /* 2422 E> */ B(Star), R(0),
+ /* 2434 S> */ B(LdaConstant), U8(201),
+ /* 2434 E> */ B(Star), R(0),
+ /* 2446 S> */ B(LdaConstant), U8(202),
+ /* 2446 E> */ B(Star), R(0),
+ /* 2458 S> */ B(LdaConstant), U8(203),
+ /* 2458 E> */ B(Star), R(0),
+ /* 2470 S> */ B(LdaConstant), U8(204),
+ /* 2470 E> */ B(Star), R(0),
+ /* 2482 S> */ B(LdaConstant), U8(205),
+ /* 2482 E> */ B(Star), R(0),
+ /* 2494 S> */ B(LdaConstant), U8(206),
+ /* 2494 E> */ B(Star), R(0),
+ /* 2506 S> */ B(LdaConstant), U8(207),
+ /* 2506 E> */ B(Star), R(0),
+ /* 2518 S> */ B(LdaConstant), U8(208),
+ /* 2518 E> */ B(Star), R(0),
+ /* 2530 S> */ B(LdaConstant), U8(209),
+ /* 2530 E> */ B(Star), R(0),
+ /* 2542 S> */ B(LdaConstant), U8(210),
+ /* 2542 E> */ B(Star), R(0),
+ /* 2554 S> */ B(LdaConstant), U8(211),
+ /* 2554 E> */ B(Star), R(0),
+ /* 2566 S> */ B(LdaConstant), U8(212),
+ /* 2566 E> */ B(Star), R(0),
+ /* 2578 S> */ B(LdaConstant), U8(213),
+ /* 2578 E> */ B(Star), R(0),
+ /* 2590 S> */ B(LdaConstant), U8(214),
+ /* 2590 E> */ B(Star), R(0),
+ /* 2602 S> */ B(LdaConstant), U8(215),
+ /* 2602 E> */ B(Star), R(0),
+ /* 2614 S> */ B(LdaConstant), U8(216),
+ /* 2614 E> */ B(Star), R(0),
+ /* 2626 S> */ B(LdaConstant), U8(217),
+ /* 2626 E> */ B(Star), R(0),
+ /* 2638 S> */ B(LdaConstant), U8(218),
+ /* 2638 E> */ B(Star), R(0),
+ /* 2650 S> */ B(LdaConstant), U8(219),
+ /* 2650 E> */ B(Star), R(0),
+ /* 2662 S> */ B(LdaConstant), U8(220),
+ /* 2662 E> */ B(Star), R(0),
+ /* 2674 S> */ B(LdaConstant), U8(221),
+ /* 2674 E> */ B(Star), R(0),
+ /* 2686 S> */ B(LdaConstant), U8(222),
+ /* 2686 E> */ B(Star), R(0),
+ /* 2698 S> */ B(LdaConstant), U8(223),
+ /* 2698 E> */ B(Star), R(0),
+ /* 2710 S> */ B(LdaConstant), U8(224),
+ /* 2710 E> */ B(Star), R(0),
+ /* 2722 S> */ B(LdaConstant), U8(225),
+ /* 2722 E> */ B(Star), R(0),
+ /* 2734 S> */ B(LdaConstant), U8(226),
+ /* 2734 E> */ B(Star), R(0),
+ /* 2746 S> */ B(LdaConstant), U8(227),
+ /* 2746 E> */ B(Star), R(0),
+ /* 2758 S> */ B(LdaConstant), U8(228),
+ /* 2758 E> */ B(Star), R(0),
+ /* 2770 S> */ B(LdaConstant), U8(229),
+ /* 2770 E> */ B(Star), R(0),
+ /* 2782 S> */ B(LdaConstant), U8(230),
+ /* 2782 E> */ B(Star), R(0),
+ /* 2794 S> */ B(LdaConstant), U8(231),
+ /* 2794 E> */ B(Star), R(0),
+ /* 2806 S> */ B(LdaConstant), U8(232),
+ /* 2806 E> */ B(Star), R(0),
+ /* 2818 S> */ B(LdaConstant), U8(233),
+ /* 2818 E> */ B(Star), R(0),
+ /* 2830 S> */ B(LdaConstant), U8(234),
+ /* 2830 E> */ B(Star), R(0),
+ /* 2842 S> */ B(LdaConstant), U8(235),
+ /* 2842 E> */ B(Star), R(0),
+ /* 2854 S> */ B(LdaConstant), U8(236),
+ /* 2854 E> */ B(Star), R(0),
+ /* 2866 S> */ B(LdaConstant), U8(237),
+ /* 2866 E> */ B(Star), R(0),
+ /* 2878 S> */ B(LdaConstant), U8(238),
+ /* 2878 E> */ B(Star), R(0),
+ /* 2890 S> */ B(LdaConstant), U8(239),
+ /* 2890 E> */ B(Star), R(0),
+ /* 2902 S> */ B(LdaConstant), U8(240),
+ /* 2902 E> */ B(Star), R(0),
+ /* 2914 S> */ B(LdaConstant), U8(241),
+ /* 2914 E> */ B(Star), R(0),
+ /* 2926 S> */ B(LdaConstant), U8(242),
+ /* 2926 E> */ B(Star), R(0),
+ /* 2938 S> */ B(LdaConstant), U8(243),
+ /* 2938 E> */ B(Star), R(0),
+ /* 2950 S> */ B(LdaConstant), U8(244),
+ /* 2950 E> */ B(Star), R(0),
+ /* 2962 S> */ B(LdaConstant), U8(245),
+ /* 2962 E> */ B(Star), R(0),
+ /* 2974 S> */ B(LdaConstant), U8(246),
+ /* 2974 E> */ B(Star), R(0),
+ /* 2986 S> */ B(LdaConstant), U8(247),
+ /* 2986 E> */ B(Star), R(0),
+ /* 2998 S> */ B(LdaConstant), U8(248),
+ /* 2998 E> */ B(Star), R(0),
+ /* 3010 S> */ B(LdaConstant), U8(249),
+ /* 3010 E> */ B(Star), R(0),
+ /* 3022 S> */ B(LdaConstant), U8(250),
+ /* 3022 E> */ B(Star), R(0),
+ /* 3034 S> */ B(LdaConstant), U8(251),
+ /* 3034 E> */ B(Star), R(0),
+ /* 3046 S> */ B(LdaConstant), U8(252),
+ /* 3046 E> */ B(Star), R(0),
+ /* 3058 S> */ B(LdaConstant), U8(253),
+ /* 3058 E> */ B(Star), R(0),
+ /* 3070 S> */ B(LdaConstant), U8(254),
+ /* 3070 E> */ B(Star), R(0),
+ /* 3082 S> */ B(LdaConstant), U8(255),
+ /* 3082 E> */ B(Star), R(0),
+ /* 3086 S> */ B(Wide), B(LdaLookupSlot), U16(256),
+ /* 3095 S> */ B(Return),
]
constant pool: [
InstanceType::HEAP_NUMBER_TYPE,
@@ -1332,522 +1332,522 @@
parameter count: 1
bytecode array length: 1031
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(2),
- B(Star), R(0),
- B(LdaConstant), U8(3),
- B(Star), R(0),
- B(LdaConstant), U8(4),
- B(Star), R(0),
- B(LdaConstant), U8(5),
- B(Star), R(0),
- B(LdaConstant), U8(6),
- B(Star), R(0),
- B(LdaConstant), U8(7),
- B(Star), R(0),
- B(LdaConstant), U8(8),
- B(Star), R(0),
- B(LdaConstant), U8(9),
- B(Star), R(0),
- B(LdaConstant), U8(10),
- B(Star), R(0),
- B(LdaConstant), U8(11),
- B(Star), R(0),
- B(LdaConstant), U8(12),
- B(Star), R(0),
- B(LdaConstant), U8(13),
- B(Star), R(0),
- B(LdaConstant), U8(14),
- B(Star), R(0),
- B(LdaConstant), U8(15),
- B(Star), R(0),
- B(LdaConstant), U8(16),
- B(Star), R(0),
- B(LdaConstant), U8(17),
- B(Star), R(0),
- B(LdaConstant), U8(18),
- B(Star), R(0),
- B(LdaConstant), U8(19),
- B(Star), R(0),
- B(LdaConstant), U8(20),
- B(Star), R(0),
- B(LdaConstant), U8(21),
- B(Star), R(0),
- B(LdaConstant), U8(22),
- B(Star), R(0),
- B(LdaConstant), U8(23),
- B(Star), R(0),
- B(LdaConstant), U8(24),
- B(Star), R(0),
- B(LdaConstant), U8(25),
- B(Star), R(0),
- B(LdaConstant), U8(26),
- B(Star), R(0),
- B(LdaConstant), U8(27),
- B(Star), R(0),
- B(LdaConstant), U8(28),
- B(Star), R(0),
- B(LdaConstant), U8(29),
- B(Star), R(0),
- B(LdaConstant), U8(30),
- B(Star), R(0),
- B(LdaConstant), U8(31),
- B(Star), R(0),
- B(LdaConstant), U8(32),
- B(Star), R(0),
- B(LdaConstant), U8(33),
- B(Star), R(0),
- B(LdaConstant), U8(34),
- B(Star), R(0),
- B(LdaConstant), U8(35),
- B(Star), R(0),
- B(LdaConstant), U8(36),
- B(Star), R(0),
- B(LdaConstant), U8(37),
- B(Star), R(0),
- B(LdaConstant), U8(38),
- B(Star), R(0),
- B(LdaConstant), U8(39),
- B(Star), R(0),
- B(LdaConstant), U8(40),
- B(Star), R(0),
- B(LdaConstant), U8(41),
- B(Star), R(0),
- B(LdaConstant), U8(42),
- B(Star), R(0),
- B(LdaConstant), U8(43),
- B(Star), R(0),
- B(LdaConstant), U8(44),
- B(Star), R(0),
- B(LdaConstant), U8(45),
- B(Star), R(0),
- B(LdaConstant), U8(46),
- B(Star), R(0),
- B(LdaConstant), U8(47),
- B(Star), R(0),
- B(LdaConstant), U8(48),
- B(Star), R(0),
- B(LdaConstant), U8(49),
- B(Star), R(0),
- B(LdaConstant), U8(50),
- B(Star), R(0),
- B(LdaConstant), U8(51),
- B(Star), R(0),
- B(LdaConstant), U8(52),
- B(Star), R(0),
- B(LdaConstant), U8(53),
- B(Star), R(0),
- B(LdaConstant), U8(54),
- B(Star), R(0),
- B(LdaConstant), U8(55),
- B(Star), R(0),
- B(LdaConstant), U8(56),
- B(Star), R(0),
- B(LdaConstant), U8(57),
- B(Star), R(0),
- B(LdaConstant), U8(58),
- B(Star), R(0),
- B(LdaConstant), U8(59),
- B(Star), R(0),
- B(LdaConstant), U8(60),
- B(Star), R(0),
- B(LdaConstant), U8(61),
- B(Star), R(0),
- B(LdaConstant), U8(62),
- B(Star), R(0),
- B(LdaConstant), U8(63),
- B(Star), R(0),
- B(LdaConstant), U8(64),
- B(Star), R(0),
- B(LdaConstant), U8(65),
- B(Star), R(0),
- B(LdaConstant), U8(66),
- B(Star), R(0),
- B(LdaConstant), U8(67),
- B(Star), R(0),
- B(LdaConstant), U8(68),
- B(Star), R(0),
- B(LdaConstant), U8(69),
- B(Star), R(0),
- B(LdaConstant), U8(70),
- B(Star), R(0),
- B(LdaConstant), U8(71),
- B(Star), R(0),
- B(LdaConstant), U8(72),
- B(Star), R(0),
- B(LdaConstant), U8(73),
- B(Star), R(0),
- B(LdaConstant), U8(74),
- B(Star), R(0),
- B(LdaConstant), U8(75),
- B(Star), R(0),
- B(LdaConstant), U8(76),
- B(Star), R(0),
- B(LdaConstant), U8(77),
- B(Star), R(0),
- B(LdaConstant), U8(78),
- B(Star), R(0),
- B(LdaConstant), U8(79),
- B(Star), R(0),
- B(LdaConstant), U8(80),
- B(Star), R(0),
- B(LdaConstant), U8(81),
- B(Star), R(0),
- B(LdaConstant), U8(82),
- B(Star), R(0),
- B(LdaConstant), U8(83),
- B(Star), R(0),
- B(LdaConstant), U8(84),
- B(Star), R(0),
- B(LdaConstant), U8(85),
- B(Star), R(0),
- B(LdaConstant), U8(86),
- B(Star), R(0),
- B(LdaConstant), U8(87),
- B(Star), R(0),
- B(LdaConstant), U8(88),
- B(Star), R(0),
- B(LdaConstant), U8(89),
- B(Star), R(0),
- B(LdaConstant), U8(90),
- B(Star), R(0),
- B(LdaConstant), U8(91),
- B(Star), R(0),
- B(LdaConstant), U8(92),
- B(Star), R(0),
- B(LdaConstant), U8(93),
- B(Star), R(0),
- B(LdaConstant), U8(94),
- B(Star), R(0),
- B(LdaConstant), U8(95),
- B(Star), R(0),
- B(LdaConstant), U8(96),
- B(Star), R(0),
- B(LdaConstant), U8(97),
- B(Star), R(0),
- B(LdaConstant), U8(98),
- B(Star), R(0),
- B(LdaConstant), U8(99),
- B(Star), R(0),
- B(LdaConstant), U8(100),
- B(Star), R(0),
- B(LdaConstant), U8(101),
- B(Star), R(0),
- B(LdaConstant), U8(102),
- B(Star), R(0),
- B(LdaConstant), U8(103),
- B(Star), R(0),
- B(LdaConstant), U8(104),
- B(Star), R(0),
- B(LdaConstant), U8(105),
- B(Star), R(0),
- B(LdaConstant), U8(106),
- B(Star), R(0),
- B(LdaConstant), U8(107),
- B(Star), R(0),
- B(LdaConstant), U8(108),
- B(Star), R(0),
- B(LdaConstant), U8(109),
- B(Star), R(0),
- B(LdaConstant), U8(110),
- B(Star), R(0),
- B(LdaConstant), U8(111),
- B(Star), R(0),
- B(LdaConstant), U8(112),
- B(Star), R(0),
- B(LdaConstant), U8(113),
- B(Star), R(0),
- B(LdaConstant), U8(114),
- B(Star), R(0),
- B(LdaConstant), U8(115),
- B(Star), R(0),
- B(LdaConstant), U8(116),
- B(Star), R(0),
- B(LdaConstant), U8(117),
- B(Star), R(0),
- B(LdaConstant), U8(118),
- B(Star), R(0),
- B(LdaConstant), U8(119),
- B(Star), R(0),
- B(LdaConstant), U8(120),
- B(Star), R(0),
- B(LdaConstant), U8(121),
- B(Star), R(0),
- B(LdaConstant), U8(122),
- B(Star), R(0),
- B(LdaConstant), U8(123),
- B(Star), R(0),
- B(LdaConstant), U8(124),
- B(Star), R(0),
- B(LdaConstant), U8(125),
- B(Star), R(0),
- B(LdaConstant), U8(126),
- B(Star), R(0),
- B(LdaConstant), U8(127),
- B(Star), R(0),
- B(LdaConstant), U8(128),
- B(Star), R(0),
- B(LdaConstant), U8(129),
- B(Star), R(0),
- B(LdaConstant), U8(130),
- B(Star), R(0),
- B(LdaConstant), U8(131),
- B(Star), R(0),
- B(LdaConstant), U8(132),
- B(Star), R(0),
- B(LdaConstant), U8(133),
- B(Star), R(0),
- B(LdaConstant), U8(134),
- B(Star), R(0),
- B(LdaConstant), U8(135),
- B(Star), R(0),
- B(LdaConstant), U8(136),
- B(Star), R(0),
- B(LdaConstant), U8(137),
- B(Star), R(0),
- B(LdaConstant), U8(138),
- B(Star), R(0),
- B(LdaConstant), U8(139),
- B(Star), R(0),
- B(LdaConstant), U8(140),
- B(Star), R(0),
- B(LdaConstant), U8(141),
- B(Star), R(0),
- B(LdaConstant), U8(142),
- B(Star), R(0),
- B(LdaConstant), U8(143),
- B(Star), R(0),
- B(LdaConstant), U8(144),
- B(Star), R(0),
- B(LdaConstant), U8(145),
- B(Star), R(0),
- B(LdaConstant), U8(146),
- B(Star), R(0),
- B(LdaConstant), U8(147),
- B(Star), R(0),
- B(LdaConstant), U8(148),
- B(Star), R(0),
- B(LdaConstant), U8(149),
- B(Star), R(0),
- B(LdaConstant), U8(150),
- B(Star), R(0),
- B(LdaConstant), U8(151),
- B(Star), R(0),
- B(LdaConstant), U8(152),
- B(Star), R(0),
- B(LdaConstant), U8(153),
- B(Star), R(0),
- B(LdaConstant), U8(154),
- B(Star), R(0),
- B(LdaConstant), U8(155),
- B(Star), R(0),
- B(LdaConstant), U8(156),
- B(Star), R(0),
- B(LdaConstant), U8(157),
- B(Star), R(0),
- B(LdaConstant), U8(158),
- B(Star), R(0),
- B(LdaConstant), U8(159),
- B(Star), R(0),
- B(LdaConstant), U8(160),
- B(Star), R(0),
- B(LdaConstant), U8(161),
- B(Star), R(0),
- B(LdaConstant), U8(162),
- B(Star), R(0),
- B(LdaConstant), U8(163),
- B(Star), R(0),
- B(LdaConstant), U8(164),
- B(Star), R(0),
- B(LdaConstant), U8(165),
- B(Star), R(0),
- B(LdaConstant), U8(166),
- B(Star), R(0),
- B(LdaConstant), U8(167),
- B(Star), R(0),
- B(LdaConstant), U8(168),
- B(Star), R(0),
- B(LdaConstant), U8(169),
- B(Star), R(0),
- B(LdaConstant), U8(170),
- B(Star), R(0),
- B(LdaConstant), U8(171),
- B(Star), R(0),
- B(LdaConstant), U8(172),
- B(Star), R(0),
- B(LdaConstant), U8(173),
- B(Star), R(0),
- B(LdaConstant), U8(174),
- B(Star), R(0),
- B(LdaConstant), U8(175),
- B(Star), R(0),
- B(LdaConstant), U8(176),
- B(Star), R(0),
- B(LdaConstant), U8(177),
- B(Star), R(0),
- B(LdaConstant), U8(178),
- B(Star), R(0),
- B(LdaConstant), U8(179),
- B(Star), R(0),
- B(LdaConstant), U8(180),
- B(Star), R(0),
- B(LdaConstant), U8(181),
- B(Star), R(0),
- B(LdaConstant), U8(182),
- B(Star), R(0),
- B(LdaConstant), U8(183),
- B(Star), R(0),
- B(LdaConstant), U8(184),
- B(Star), R(0),
- B(LdaConstant), U8(185),
- B(Star), R(0),
- B(LdaConstant), U8(186),
- B(Star), R(0),
- B(LdaConstant), U8(187),
- B(Star), R(0),
- B(LdaConstant), U8(188),
- B(Star), R(0),
- B(LdaConstant), U8(189),
- B(Star), R(0),
- B(LdaConstant), U8(190),
- B(Star), R(0),
- B(LdaConstant), U8(191),
- B(Star), R(0),
- B(LdaConstant), U8(192),
- B(Star), R(0),
- B(LdaConstant), U8(193),
- B(Star), R(0),
- B(LdaConstant), U8(194),
- B(Star), R(0),
- B(LdaConstant), U8(195),
- B(Star), R(0),
- B(LdaConstant), U8(196),
- B(Star), R(0),
- B(LdaConstant), U8(197),
- B(Star), R(0),
- B(LdaConstant), U8(198),
- B(Star), R(0),
- B(LdaConstant), U8(199),
- B(Star), R(0),
- B(LdaConstant), U8(200),
- B(Star), R(0),
- B(LdaConstant), U8(201),
- B(Star), R(0),
- B(LdaConstant), U8(202),
- B(Star), R(0),
- B(LdaConstant), U8(203),
- B(Star), R(0),
- B(LdaConstant), U8(204),
- B(Star), R(0),
- B(LdaConstant), U8(205),
- B(Star), R(0),
- B(LdaConstant), U8(206),
- B(Star), R(0),
- B(LdaConstant), U8(207),
- B(Star), R(0),
- B(LdaConstant), U8(208),
- B(Star), R(0),
- B(LdaConstant), U8(209),
- B(Star), R(0),
- B(LdaConstant), U8(210),
- B(Star), R(0),
- B(LdaConstant), U8(211),
- B(Star), R(0),
- B(LdaConstant), U8(212),
- B(Star), R(0),
- B(LdaConstant), U8(213),
- B(Star), R(0),
- B(LdaConstant), U8(214),
- B(Star), R(0),
- B(LdaConstant), U8(215),
- B(Star), R(0),
- B(LdaConstant), U8(216),
- B(Star), R(0),
- B(LdaConstant), U8(217),
- B(Star), R(0),
- B(LdaConstant), U8(218),
- B(Star), R(0),
- B(LdaConstant), U8(219),
- B(Star), R(0),
- B(LdaConstant), U8(220),
- B(Star), R(0),
- B(LdaConstant), U8(221),
- B(Star), R(0),
- B(LdaConstant), U8(222),
- B(Star), R(0),
- B(LdaConstant), U8(223),
- B(Star), R(0),
- B(LdaConstant), U8(224),
- B(Star), R(0),
- B(LdaConstant), U8(225),
- B(Star), R(0),
- B(LdaConstant), U8(226),
- B(Star), R(0),
- B(LdaConstant), U8(227),
- B(Star), R(0),
- B(LdaConstant), U8(228),
- B(Star), R(0),
- B(LdaConstant), U8(229),
- B(Star), R(0),
- B(LdaConstant), U8(230),
- B(Star), R(0),
- B(LdaConstant), U8(231),
- B(Star), R(0),
- B(LdaConstant), U8(232),
- B(Star), R(0),
- B(LdaConstant), U8(233),
- B(Star), R(0),
- B(LdaConstant), U8(234),
- B(Star), R(0),
- B(LdaConstant), U8(235),
- B(Star), R(0),
- B(LdaConstant), U8(236),
- B(Star), R(0),
- B(LdaConstant), U8(237),
- B(Star), R(0),
- B(LdaConstant), U8(238),
- B(Star), R(0),
- B(LdaConstant), U8(239),
- B(Star), R(0),
- B(LdaConstant), U8(240),
- B(Star), R(0),
- B(LdaConstant), U8(241),
- B(Star), R(0),
- B(LdaConstant), U8(242),
- B(Star), R(0),
- B(LdaConstant), U8(243),
- B(Star), R(0),
- B(LdaConstant), U8(244),
- B(Star), R(0),
- B(LdaConstant), U8(245),
- B(Star), R(0),
- B(LdaConstant), U8(246),
- B(Star), R(0),
- B(LdaConstant), U8(247),
- B(Star), R(0),
- B(LdaConstant), U8(248),
- B(Star), R(0),
- B(LdaConstant), U8(249),
- B(Star), R(0),
- B(LdaConstant), U8(250),
- B(Star), R(0),
- B(LdaConstant), U8(251),
- B(Star), R(0),
- B(LdaConstant), U8(252),
- B(Star), R(0),
- B(LdaConstant), U8(253),
- B(Star), R(0),
- B(LdaConstant), U8(254),
- B(Star), R(0),
- B(LdaConstant), U8(255),
- B(Star), R(0),
- B(Wide), B(LdaLookupSlotInsideTypeof), U16(256),
- B(TypeOf),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 22 S> */ B(LdaConstant), U8(0),
+ /* 22 E> */ B(Star), R(0),
+ /* 34 S> */ B(LdaConstant), U8(1),
+ /* 34 E> */ B(Star), R(0),
+ /* 46 S> */ B(LdaConstant), U8(2),
+ /* 46 E> */ B(Star), R(0),
+ /* 58 S> */ B(LdaConstant), U8(3),
+ /* 58 E> */ B(Star), R(0),
+ /* 70 S> */ B(LdaConstant), U8(4),
+ /* 70 E> */ B(Star), R(0),
+ /* 82 S> */ B(LdaConstant), U8(5),
+ /* 82 E> */ B(Star), R(0),
+ /* 94 S> */ B(LdaConstant), U8(6),
+ /* 94 E> */ B(Star), R(0),
+ /* 106 S> */ B(LdaConstant), U8(7),
+ /* 106 E> */ B(Star), R(0),
+ /* 118 S> */ B(LdaConstant), U8(8),
+ /* 118 E> */ B(Star), R(0),
+ /* 130 S> */ B(LdaConstant), U8(9),
+ /* 130 E> */ B(Star), R(0),
+ /* 142 S> */ B(LdaConstant), U8(10),
+ /* 142 E> */ B(Star), R(0),
+ /* 154 S> */ B(LdaConstant), U8(11),
+ /* 154 E> */ B(Star), R(0),
+ /* 166 S> */ B(LdaConstant), U8(12),
+ /* 166 E> */ B(Star), R(0),
+ /* 178 S> */ B(LdaConstant), U8(13),
+ /* 178 E> */ B(Star), R(0),
+ /* 190 S> */ B(LdaConstant), U8(14),
+ /* 190 E> */ B(Star), R(0),
+ /* 202 S> */ B(LdaConstant), U8(15),
+ /* 202 E> */ B(Star), R(0),
+ /* 214 S> */ B(LdaConstant), U8(16),
+ /* 214 E> */ B(Star), R(0),
+ /* 226 S> */ B(LdaConstant), U8(17),
+ /* 226 E> */ B(Star), R(0),
+ /* 238 S> */ B(LdaConstant), U8(18),
+ /* 238 E> */ B(Star), R(0),
+ /* 250 S> */ B(LdaConstant), U8(19),
+ /* 250 E> */ B(Star), R(0),
+ /* 262 S> */ B(LdaConstant), U8(20),
+ /* 262 E> */ B(Star), R(0),
+ /* 274 S> */ B(LdaConstant), U8(21),
+ /* 274 E> */ B(Star), R(0),
+ /* 286 S> */ B(LdaConstant), U8(22),
+ /* 286 E> */ B(Star), R(0),
+ /* 298 S> */ B(LdaConstant), U8(23),
+ /* 298 E> */ B(Star), R(0),
+ /* 310 S> */ B(LdaConstant), U8(24),
+ /* 310 E> */ B(Star), R(0),
+ /* 322 S> */ B(LdaConstant), U8(25),
+ /* 322 E> */ B(Star), R(0),
+ /* 334 S> */ B(LdaConstant), U8(26),
+ /* 334 E> */ B(Star), R(0),
+ /* 346 S> */ B(LdaConstant), U8(27),
+ /* 346 E> */ B(Star), R(0),
+ /* 358 S> */ B(LdaConstant), U8(28),
+ /* 358 E> */ B(Star), R(0),
+ /* 370 S> */ B(LdaConstant), U8(29),
+ /* 370 E> */ B(Star), R(0),
+ /* 382 S> */ B(LdaConstant), U8(30),
+ /* 382 E> */ B(Star), R(0),
+ /* 394 S> */ B(LdaConstant), U8(31),
+ /* 394 E> */ B(Star), R(0),
+ /* 406 S> */ B(LdaConstant), U8(32),
+ /* 406 E> */ B(Star), R(0),
+ /* 418 S> */ B(LdaConstant), U8(33),
+ /* 418 E> */ B(Star), R(0),
+ /* 430 S> */ B(LdaConstant), U8(34),
+ /* 430 E> */ B(Star), R(0),
+ /* 442 S> */ B(LdaConstant), U8(35),
+ /* 442 E> */ B(Star), R(0),
+ /* 454 S> */ B(LdaConstant), U8(36),
+ /* 454 E> */ B(Star), R(0),
+ /* 466 S> */ B(LdaConstant), U8(37),
+ /* 466 E> */ B(Star), R(0),
+ /* 478 S> */ B(LdaConstant), U8(38),
+ /* 478 E> */ B(Star), R(0),
+ /* 490 S> */ B(LdaConstant), U8(39),
+ /* 490 E> */ B(Star), R(0),
+ /* 502 S> */ B(LdaConstant), U8(40),
+ /* 502 E> */ B(Star), R(0),
+ /* 514 S> */ B(LdaConstant), U8(41),
+ /* 514 E> */ B(Star), R(0),
+ /* 526 S> */ B(LdaConstant), U8(42),
+ /* 526 E> */ B(Star), R(0),
+ /* 538 S> */ B(LdaConstant), U8(43),
+ /* 538 E> */ B(Star), R(0),
+ /* 550 S> */ B(LdaConstant), U8(44),
+ /* 550 E> */ B(Star), R(0),
+ /* 562 S> */ B(LdaConstant), U8(45),
+ /* 562 E> */ B(Star), R(0),
+ /* 574 S> */ B(LdaConstant), U8(46),
+ /* 574 E> */ B(Star), R(0),
+ /* 586 S> */ B(LdaConstant), U8(47),
+ /* 586 E> */ B(Star), R(0),
+ /* 598 S> */ B(LdaConstant), U8(48),
+ /* 598 E> */ B(Star), R(0),
+ /* 610 S> */ B(LdaConstant), U8(49),
+ /* 610 E> */ B(Star), R(0),
+ /* 622 S> */ B(LdaConstant), U8(50),
+ /* 622 E> */ B(Star), R(0),
+ /* 634 S> */ B(LdaConstant), U8(51),
+ /* 634 E> */ B(Star), R(0),
+ /* 646 S> */ B(LdaConstant), U8(52),
+ /* 646 E> */ B(Star), R(0),
+ /* 658 S> */ B(LdaConstant), U8(53),
+ /* 658 E> */ B(Star), R(0),
+ /* 670 S> */ B(LdaConstant), U8(54),
+ /* 670 E> */ B(Star), R(0),
+ /* 682 S> */ B(LdaConstant), U8(55),
+ /* 682 E> */ B(Star), R(0),
+ /* 694 S> */ B(LdaConstant), U8(56),
+ /* 694 E> */ B(Star), R(0),
+ /* 706 S> */ B(LdaConstant), U8(57),
+ /* 706 E> */ B(Star), R(0),
+ /* 718 S> */ B(LdaConstant), U8(58),
+ /* 718 E> */ B(Star), R(0),
+ /* 730 S> */ B(LdaConstant), U8(59),
+ /* 730 E> */ B(Star), R(0),
+ /* 742 S> */ B(LdaConstant), U8(60),
+ /* 742 E> */ B(Star), R(0),
+ /* 754 S> */ B(LdaConstant), U8(61),
+ /* 754 E> */ B(Star), R(0),
+ /* 766 S> */ B(LdaConstant), U8(62),
+ /* 766 E> */ B(Star), R(0),
+ /* 778 S> */ B(LdaConstant), U8(63),
+ /* 778 E> */ B(Star), R(0),
+ /* 790 S> */ B(LdaConstant), U8(64),
+ /* 790 E> */ B(Star), R(0),
+ /* 802 S> */ B(LdaConstant), U8(65),
+ /* 802 E> */ B(Star), R(0),
+ /* 814 S> */ B(LdaConstant), U8(66),
+ /* 814 E> */ B(Star), R(0),
+ /* 826 S> */ B(LdaConstant), U8(67),
+ /* 826 E> */ B(Star), R(0),
+ /* 838 S> */ B(LdaConstant), U8(68),
+ /* 838 E> */ B(Star), R(0),
+ /* 850 S> */ B(LdaConstant), U8(69),
+ /* 850 E> */ B(Star), R(0),
+ /* 862 S> */ B(LdaConstant), U8(70),
+ /* 862 E> */ B(Star), R(0),
+ /* 874 S> */ B(LdaConstant), U8(71),
+ /* 874 E> */ B(Star), R(0),
+ /* 886 S> */ B(LdaConstant), U8(72),
+ /* 886 E> */ B(Star), R(0),
+ /* 898 S> */ B(LdaConstant), U8(73),
+ /* 898 E> */ B(Star), R(0),
+ /* 910 S> */ B(LdaConstant), U8(74),
+ /* 910 E> */ B(Star), R(0),
+ /* 922 S> */ B(LdaConstant), U8(75),
+ /* 922 E> */ B(Star), R(0),
+ /* 934 S> */ B(LdaConstant), U8(76),
+ /* 934 E> */ B(Star), R(0),
+ /* 946 S> */ B(LdaConstant), U8(77),
+ /* 946 E> */ B(Star), R(0),
+ /* 958 S> */ B(LdaConstant), U8(78),
+ /* 958 E> */ B(Star), R(0),
+ /* 970 S> */ B(LdaConstant), U8(79),
+ /* 970 E> */ B(Star), R(0),
+ /* 982 S> */ B(LdaConstant), U8(80),
+ /* 982 E> */ B(Star), R(0),
+ /* 994 S> */ B(LdaConstant), U8(81),
+ /* 994 E> */ B(Star), R(0),
+ /* 1006 S> */ B(LdaConstant), U8(82),
+ /* 1006 E> */ B(Star), R(0),
+ /* 1018 S> */ B(LdaConstant), U8(83),
+ /* 1018 E> */ B(Star), R(0),
+ /* 1030 S> */ B(LdaConstant), U8(84),
+ /* 1030 E> */ B(Star), R(0),
+ /* 1042 S> */ B(LdaConstant), U8(85),
+ /* 1042 E> */ B(Star), R(0),
+ /* 1054 S> */ B(LdaConstant), U8(86),
+ /* 1054 E> */ B(Star), R(0),
+ /* 1066 S> */ B(LdaConstant), U8(87),
+ /* 1066 E> */ B(Star), R(0),
+ /* 1078 S> */ B(LdaConstant), U8(88),
+ /* 1078 E> */ B(Star), R(0),
+ /* 1090 S> */ B(LdaConstant), U8(89),
+ /* 1090 E> */ B(Star), R(0),
+ /* 1102 S> */ B(LdaConstant), U8(90),
+ /* 1102 E> */ B(Star), R(0),
+ /* 1114 S> */ B(LdaConstant), U8(91),
+ /* 1114 E> */ B(Star), R(0),
+ /* 1126 S> */ B(LdaConstant), U8(92),
+ /* 1126 E> */ B(Star), R(0),
+ /* 1138 S> */ B(LdaConstant), U8(93),
+ /* 1138 E> */ B(Star), R(0),
+ /* 1150 S> */ B(LdaConstant), U8(94),
+ /* 1150 E> */ B(Star), R(0),
+ /* 1162 S> */ B(LdaConstant), U8(95),
+ /* 1162 E> */ B(Star), R(0),
+ /* 1174 S> */ B(LdaConstant), U8(96),
+ /* 1174 E> */ B(Star), R(0),
+ /* 1186 S> */ B(LdaConstant), U8(97),
+ /* 1186 E> */ B(Star), R(0),
+ /* 1198 S> */ B(LdaConstant), U8(98),
+ /* 1198 E> */ B(Star), R(0),
+ /* 1210 S> */ B(LdaConstant), U8(99),
+ /* 1210 E> */ B(Star), R(0),
+ /* 1222 S> */ B(LdaConstant), U8(100),
+ /* 1222 E> */ B(Star), R(0),
+ /* 1234 S> */ B(LdaConstant), U8(101),
+ /* 1234 E> */ B(Star), R(0),
+ /* 1246 S> */ B(LdaConstant), U8(102),
+ /* 1246 E> */ B(Star), R(0),
+ /* 1258 S> */ B(LdaConstant), U8(103),
+ /* 1258 E> */ B(Star), R(0),
+ /* 1270 S> */ B(LdaConstant), U8(104),
+ /* 1270 E> */ B(Star), R(0),
+ /* 1282 S> */ B(LdaConstant), U8(105),
+ /* 1282 E> */ B(Star), R(0),
+ /* 1294 S> */ B(LdaConstant), U8(106),
+ /* 1294 E> */ B(Star), R(0),
+ /* 1306 S> */ B(LdaConstant), U8(107),
+ /* 1306 E> */ B(Star), R(0),
+ /* 1318 S> */ B(LdaConstant), U8(108),
+ /* 1318 E> */ B(Star), R(0),
+ /* 1330 S> */ B(LdaConstant), U8(109),
+ /* 1330 E> */ B(Star), R(0),
+ /* 1342 S> */ B(LdaConstant), U8(110),
+ /* 1342 E> */ B(Star), R(0),
+ /* 1354 S> */ B(LdaConstant), U8(111),
+ /* 1354 E> */ B(Star), R(0),
+ /* 1366 S> */ B(LdaConstant), U8(112),
+ /* 1366 E> */ B(Star), R(0),
+ /* 1378 S> */ B(LdaConstant), U8(113),
+ /* 1378 E> */ B(Star), R(0),
+ /* 1390 S> */ B(LdaConstant), U8(114),
+ /* 1390 E> */ B(Star), R(0),
+ /* 1402 S> */ B(LdaConstant), U8(115),
+ /* 1402 E> */ B(Star), R(0),
+ /* 1414 S> */ B(LdaConstant), U8(116),
+ /* 1414 E> */ B(Star), R(0),
+ /* 1426 S> */ B(LdaConstant), U8(117),
+ /* 1426 E> */ B(Star), R(0),
+ /* 1438 S> */ B(LdaConstant), U8(118),
+ /* 1438 E> */ B(Star), R(0),
+ /* 1450 S> */ B(LdaConstant), U8(119),
+ /* 1450 E> */ B(Star), R(0),
+ /* 1462 S> */ B(LdaConstant), U8(120),
+ /* 1462 E> */ B(Star), R(0),
+ /* 1474 S> */ B(LdaConstant), U8(121),
+ /* 1474 E> */ B(Star), R(0),
+ /* 1486 S> */ B(LdaConstant), U8(122),
+ /* 1486 E> */ B(Star), R(0),
+ /* 1498 S> */ B(LdaConstant), U8(123),
+ /* 1498 E> */ B(Star), R(0),
+ /* 1510 S> */ B(LdaConstant), U8(124),
+ /* 1510 E> */ B(Star), R(0),
+ /* 1522 S> */ B(LdaConstant), U8(125),
+ /* 1522 E> */ B(Star), R(0),
+ /* 1534 S> */ B(LdaConstant), U8(126),
+ /* 1534 E> */ B(Star), R(0),
+ /* 1546 S> */ B(LdaConstant), U8(127),
+ /* 1546 E> */ B(Star), R(0),
+ /* 1558 S> */ B(LdaConstant), U8(128),
+ /* 1558 E> */ B(Star), R(0),
+ /* 1570 S> */ B(LdaConstant), U8(129),
+ /* 1570 E> */ B(Star), R(0),
+ /* 1582 S> */ B(LdaConstant), U8(130),
+ /* 1582 E> */ B(Star), R(0),
+ /* 1594 S> */ B(LdaConstant), U8(131),
+ /* 1594 E> */ B(Star), R(0),
+ /* 1606 S> */ B(LdaConstant), U8(132),
+ /* 1606 E> */ B(Star), R(0),
+ /* 1618 S> */ B(LdaConstant), U8(133),
+ /* 1618 E> */ B(Star), R(0),
+ /* 1630 S> */ B(LdaConstant), U8(134),
+ /* 1630 E> */ B(Star), R(0),
+ /* 1642 S> */ B(LdaConstant), U8(135),
+ /* 1642 E> */ B(Star), R(0),
+ /* 1654 S> */ B(LdaConstant), U8(136),
+ /* 1654 E> */ B(Star), R(0),
+ /* 1666 S> */ B(LdaConstant), U8(137),
+ /* 1666 E> */ B(Star), R(0),
+ /* 1678 S> */ B(LdaConstant), U8(138),
+ /* 1678 E> */ B(Star), R(0),
+ /* 1690 S> */ B(LdaConstant), U8(139),
+ /* 1690 E> */ B(Star), R(0),
+ /* 1702 S> */ B(LdaConstant), U8(140),
+ /* 1702 E> */ B(Star), R(0),
+ /* 1714 S> */ B(LdaConstant), U8(141),
+ /* 1714 E> */ B(Star), R(0),
+ /* 1726 S> */ B(LdaConstant), U8(142),
+ /* 1726 E> */ B(Star), R(0),
+ /* 1738 S> */ B(LdaConstant), U8(143),
+ /* 1738 E> */ B(Star), R(0),
+ /* 1750 S> */ B(LdaConstant), U8(144),
+ /* 1750 E> */ B(Star), R(0),
+ /* 1762 S> */ B(LdaConstant), U8(145),
+ /* 1762 E> */ B(Star), R(0),
+ /* 1774 S> */ B(LdaConstant), U8(146),
+ /* 1774 E> */ B(Star), R(0),
+ /* 1786 S> */ B(LdaConstant), U8(147),
+ /* 1786 E> */ B(Star), R(0),
+ /* 1798 S> */ B(LdaConstant), U8(148),
+ /* 1798 E> */ B(Star), R(0),
+ /* 1810 S> */ B(LdaConstant), U8(149),
+ /* 1810 E> */ B(Star), R(0),
+ /* 1822 S> */ B(LdaConstant), U8(150),
+ /* 1822 E> */ B(Star), R(0),
+ /* 1834 S> */ B(LdaConstant), U8(151),
+ /* 1834 E> */ B(Star), R(0),
+ /* 1846 S> */ B(LdaConstant), U8(152),
+ /* 1846 E> */ B(Star), R(0),
+ /* 1858 S> */ B(LdaConstant), U8(153),
+ /* 1858 E> */ B(Star), R(0),
+ /* 1870 S> */ B(LdaConstant), U8(154),
+ /* 1870 E> */ B(Star), R(0),
+ /* 1882 S> */ B(LdaConstant), U8(155),
+ /* 1882 E> */ B(Star), R(0),
+ /* 1894 S> */ B(LdaConstant), U8(156),
+ /* 1894 E> */ B(Star), R(0),
+ /* 1906 S> */ B(LdaConstant), U8(157),
+ /* 1906 E> */ B(Star), R(0),
+ /* 1918 S> */ B(LdaConstant), U8(158),
+ /* 1918 E> */ B(Star), R(0),
+ /* 1930 S> */ B(LdaConstant), U8(159),
+ /* 1930 E> */ B(Star), R(0),
+ /* 1942 S> */ B(LdaConstant), U8(160),
+ /* 1942 E> */ B(Star), R(0),
+ /* 1954 S> */ B(LdaConstant), U8(161),
+ /* 1954 E> */ B(Star), R(0),
+ /* 1966 S> */ B(LdaConstant), U8(162),
+ /* 1966 E> */ B(Star), R(0),
+ /* 1978 S> */ B(LdaConstant), U8(163),
+ /* 1978 E> */ B(Star), R(0),
+ /* 1990 S> */ B(LdaConstant), U8(164),
+ /* 1990 E> */ B(Star), R(0),
+ /* 2002 S> */ B(LdaConstant), U8(165),
+ /* 2002 E> */ B(Star), R(0),
+ /* 2014 S> */ B(LdaConstant), U8(166),
+ /* 2014 E> */ B(Star), R(0),
+ /* 2026 S> */ B(LdaConstant), U8(167),
+ /* 2026 E> */ B(Star), R(0),
+ /* 2038 S> */ B(LdaConstant), U8(168),
+ /* 2038 E> */ B(Star), R(0),
+ /* 2050 S> */ B(LdaConstant), U8(169),
+ /* 2050 E> */ B(Star), R(0),
+ /* 2062 S> */ B(LdaConstant), U8(170),
+ /* 2062 E> */ B(Star), R(0),
+ /* 2074 S> */ B(LdaConstant), U8(171),
+ /* 2074 E> */ B(Star), R(0),
+ /* 2086 S> */ B(LdaConstant), U8(172),
+ /* 2086 E> */ B(Star), R(0),
+ /* 2098 S> */ B(LdaConstant), U8(173),
+ /* 2098 E> */ B(Star), R(0),
+ /* 2110 S> */ B(LdaConstant), U8(174),
+ /* 2110 E> */ B(Star), R(0),
+ /* 2122 S> */ B(LdaConstant), U8(175),
+ /* 2122 E> */ B(Star), R(0),
+ /* 2134 S> */ B(LdaConstant), U8(176),
+ /* 2134 E> */ B(Star), R(0),
+ /* 2146 S> */ B(LdaConstant), U8(177),
+ /* 2146 E> */ B(Star), R(0),
+ /* 2158 S> */ B(LdaConstant), U8(178),
+ /* 2158 E> */ B(Star), R(0),
+ /* 2170 S> */ B(LdaConstant), U8(179),
+ /* 2170 E> */ B(Star), R(0),
+ /* 2182 S> */ B(LdaConstant), U8(180),
+ /* 2182 E> */ B(Star), R(0),
+ /* 2194 S> */ B(LdaConstant), U8(181),
+ /* 2194 E> */ B(Star), R(0),
+ /* 2206 S> */ B(LdaConstant), U8(182),
+ /* 2206 E> */ B(Star), R(0),
+ /* 2218 S> */ B(LdaConstant), U8(183),
+ /* 2218 E> */ B(Star), R(0),
+ /* 2230 S> */ B(LdaConstant), U8(184),
+ /* 2230 E> */ B(Star), R(0),
+ /* 2242 S> */ B(LdaConstant), U8(185),
+ /* 2242 E> */ B(Star), R(0),
+ /* 2254 S> */ B(LdaConstant), U8(186),
+ /* 2254 E> */ B(Star), R(0),
+ /* 2266 S> */ B(LdaConstant), U8(187),
+ /* 2266 E> */ B(Star), R(0),
+ /* 2278 S> */ B(LdaConstant), U8(188),
+ /* 2278 E> */ B(Star), R(0),
+ /* 2290 S> */ B(LdaConstant), U8(189),
+ /* 2290 E> */ B(Star), R(0),
+ /* 2302 S> */ B(LdaConstant), U8(190),
+ /* 2302 E> */ B(Star), R(0),
+ /* 2314 S> */ B(LdaConstant), U8(191),
+ /* 2314 E> */ B(Star), R(0),
+ /* 2326 S> */ B(LdaConstant), U8(192),
+ /* 2326 E> */ B(Star), R(0),
+ /* 2338 S> */ B(LdaConstant), U8(193),
+ /* 2338 E> */ B(Star), R(0),
+ /* 2350 S> */ B(LdaConstant), U8(194),
+ /* 2350 E> */ B(Star), R(0),
+ /* 2362 S> */ B(LdaConstant), U8(195),
+ /* 2362 E> */ B(Star), R(0),
+ /* 2374 S> */ B(LdaConstant), U8(196),
+ /* 2374 E> */ B(Star), R(0),
+ /* 2386 S> */ B(LdaConstant), U8(197),
+ /* 2386 E> */ B(Star), R(0),
+ /* 2398 S> */ B(LdaConstant), U8(198),
+ /* 2398 E> */ B(Star), R(0),
+ /* 2410 S> */ B(LdaConstant), U8(199),
+ /* 2410 E> */ B(Star), R(0),
+ /* 2422 S> */ B(LdaConstant), U8(200),
+ /* 2422 E> */ B(Star), R(0),
+ /* 2434 S> */ B(LdaConstant), U8(201),
+ /* 2434 E> */ B(Star), R(0),
+ /* 2446 S> */ B(LdaConstant), U8(202),
+ /* 2446 E> */ B(Star), R(0),
+ /* 2458 S> */ B(LdaConstant), U8(203),
+ /* 2458 E> */ B(Star), R(0),
+ /* 2470 S> */ B(LdaConstant), U8(204),
+ /* 2470 E> */ B(Star), R(0),
+ /* 2482 S> */ B(LdaConstant), U8(205),
+ /* 2482 E> */ B(Star), R(0),
+ /* 2494 S> */ B(LdaConstant), U8(206),
+ /* 2494 E> */ B(Star), R(0),
+ /* 2506 S> */ B(LdaConstant), U8(207),
+ /* 2506 E> */ B(Star), R(0),
+ /* 2518 S> */ B(LdaConstant), U8(208),
+ /* 2518 E> */ B(Star), R(0),
+ /* 2530 S> */ B(LdaConstant), U8(209),
+ /* 2530 E> */ B(Star), R(0),
+ /* 2542 S> */ B(LdaConstant), U8(210),
+ /* 2542 E> */ B(Star), R(0),
+ /* 2554 S> */ B(LdaConstant), U8(211),
+ /* 2554 E> */ B(Star), R(0),
+ /* 2566 S> */ B(LdaConstant), U8(212),
+ /* 2566 E> */ B(Star), R(0),
+ /* 2578 S> */ B(LdaConstant), U8(213),
+ /* 2578 E> */ B(Star), R(0),
+ /* 2590 S> */ B(LdaConstant), U8(214),
+ /* 2590 E> */ B(Star), R(0),
+ /* 2602 S> */ B(LdaConstant), U8(215),
+ /* 2602 E> */ B(Star), R(0),
+ /* 2614 S> */ B(LdaConstant), U8(216),
+ /* 2614 E> */ B(Star), R(0),
+ /* 2626 S> */ B(LdaConstant), U8(217),
+ /* 2626 E> */ B(Star), R(0),
+ /* 2638 S> */ B(LdaConstant), U8(218),
+ /* 2638 E> */ B(Star), R(0),
+ /* 2650 S> */ B(LdaConstant), U8(219),
+ /* 2650 E> */ B(Star), R(0),
+ /* 2662 S> */ B(LdaConstant), U8(220),
+ /* 2662 E> */ B(Star), R(0),
+ /* 2674 S> */ B(LdaConstant), U8(221),
+ /* 2674 E> */ B(Star), R(0),
+ /* 2686 S> */ B(LdaConstant), U8(222),
+ /* 2686 E> */ B(Star), R(0),
+ /* 2698 S> */ B(LdaConstant), U8(223),
+ /* 2698 E> */ B(Star), R(0),
+ /* 2710 S> */ B(LdaConstant), U8(224),
+ /* 2710 E> */ B(Star), R(0),
+ /* 2722 S> */ B(LdaConstant), U8(225),
+ /* 2722 E> */ B(Star), R(0),
+ /* 2734 S> */ B(LdaConstant), U8(226),
+ /* 2734 E> */ B(Star), R(0),
+ /* 2746 S> */ B(LdaConstant), U8(227),
+ /* 2746 E> */ B(Star), R(0),
+ /* 2758 S> */ B(LdaConstant), U8(228),
+ /* 2758 E> */ B(Star), R(0),
+ /* 2770 S> */ B(LdaConstant), U8(229),
+ /* 2770 E> */ B(Star), R(0),
+ /* 2782 S> */ B(LdaConstant), U8(230),
+ /* 2782 E> */ B(Star), R(0),
+ /* 2794 S> */ B(LdaConstant), U8(231),
+ /* 2794 E> */ B(Star), R(0),
+ /* 2806 S> */ B(LdaConstant), U8(232),
+ /* 2806 E> */ B(Star), R(0),
+ /* 2818 S> */ B(LdaConstant), U8(233),
+ /* 2818 E> */ B(Star), R(0),
+ /* 2830 S> */ B(LdaConstant), U8(234),
+ /* 2830 E> */ B(Star), R(0),
+ /* 2842 S> */ B(LdaConstant), U8(235),
+ /* 2842 E> */ B(Star), R(0),
+ /* 2854 S> */ B(LdaConstant), U8(236),
+ /* 2854 E> */ B(Star), R(0),
+ /* 2866 S> */ B(LdaConstant), U8(237),
+ /* 2866 E> */ B(Star), R(0),
+ /* 2878 S> */ B(LdaConstant), U8(238),
+ /* 2878 E> */ B(Star), R(0),
+ /* 2890 S> */ B(LdaConstant), U8(239),
+ /* 2890 E> */ B(Star), R(0),
+ /* 2902 S> */ B(LdaConstant), U8(240),
+ /* 2902 E> */ B(Star), R(0),
+ /* 2914 S> */ B(LdaConstant), U8(241),
+ /* 2914 E> */ B(Star), R(0),
+ /* 2926 S> */ B(LdaConstant), U8(242),
+ /* 2926 E> */ B(Star), R(0),
+ /* 2938 S> */ B(LdaConstant), U8(243),
+ /* 2938 E> */ B(Star), R(0),
+ /* 2950 S> */ B(LdaConstant), U8(244),
+ /* 2950 E> */ B(Star), R(0),
+ /* 2962 S> */ B(LdaConstant), U8(245),
+ /* 2962 E> */ B(Star), R(0),
+ /* 2974 S> */ B(LdaConstant), U8(246),
+ /* 2974 E> */ B(Star), R(0),
+ /* 2986 S> */ B(LdaConstant), U8(247),
+ /* 2986 E> */ B(Star), R(0),
+ /* 2998 S> */ B(LdaConstant), U8(248),
+ /* 2998 E> */ B(Star), R(0),
+ /* 3010 S> */ B(LdaConstant), U8(249),
+ /* 3010 E> */ B(Star), R(0),
+ /* 3022 S> */ B(LdaConstant), U8(250),
+ /* 3022 E> */ B(Star), R(0),
+ /* 3034 S> */ B(LdaConstant), U8(251),
+ /* 3034 E> */ B(Star), R(0),
+ /* 3046 S> */ B(LdaConstant), U8(252),
+ /* 3046 E> */ B(Star), R(0),
+ /* 3058 S> */ B(LdaConstant), U8(253),
+ /* 3058 E> */ B(Star), R(0),
+ /* 3070 S> */ B(LdaConstant), U8(254),
+ /* 3070 E> */ B(Star), R(0),
+ /* 3082 S> */ B(LdaConstant), U8(255),
+ /* 3082 E> */ B(Star), R(0),
+ /* 3086 S> */ B(Wide), B(LdaLookupSlotInsideTypeof), U16(256),
+ B(TypeOf),
+ /* 3102 S> */ B(Return),
]
constant pool: [
InstanceType::HEAP_NUMBER_TYPE,
@@ -2384,523 +2384,523 @@
parameter count: 1
bytecode array length: 1033
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(2),
- B(Star), R(0),
- B(LdaConstant), U8(3),
- B(Star), R(0),
- B(LdaConstant), U8(4),
- B(Star), R(0),
- B(LdaConstant), U8(5),
- B(Star), R(0),
- B(LdaConstant), U8(6),
- B(Star), R(0),
- B(LdaConstant), U8(7),
- B(Star), R(0),
- B(LdaConstant), U8(8),
- B(Star), R(0),
- B(LdaConstant), U8(9),
- B(Star), R(0),
- B(LdaConstant), U8(10),
- B(Star), R(0),
- B(LdaConstant), U8(11),
- B(Star), R(0),
- B(LdaConstant), U8(12),
- B(Star), R(0),
- B(LdaConstant), U8(13),
- B(Star), R(0),
- B(LdaConstant), U8(14),
- B(Star), R(0),
- B(LdaConstant), U8(15),
- B(Star), R(0),
- B(LdaConstant), U8(16),
- B(Star), R(0),
- B(LdaConstant), U8(17),
- B(Star), R(0),
- B(LdaConstant), U8(18),
- B(Star), R(0),
- B(LdaConstant), U8(19),
- B(Star), R(0),
- B(LdaConstant), U8(20),
- B(Star), R(0),
- B(LdaConstant), U8(21),
- B(Star), R(0),
- B(LdaConstant), U8(22),
- B(Star), R(0),
- B(LdaConstant), U8(23),
- B(Star), R(0),
- B(LdaConstant), U8(24),
- B(Star), R(0),
- B(LdaConstant), U8(25),
- B(Star), R(0),
- B(LdaConstant), U8(26),
- B(Star), R(0),
- B(LdaConstant), U8(27),
- B(Star), R(0),
- B(LdaConstant), U8(28),
- B(Star), R(0),
- B(LdaConstant), U8(29),
- B(Star), R(0),
- B(LdaConstant), U8(30),
- B(Star), R(0),
- B(LdaConstant), U8(31),
- B(Star), R(0),
- B(LdaConstant), U8(32),
- B(Star), R(0),
- B(LdaConstant), U8(33),
- B(Star), R(0),
- B(LdaConstant), U8(34),
- B(Star), R(0),
- B(LdaConstant), U8(35),
- B(Star), R(0),
- B(LdaConstant), U8(36),
- B(Star), R(0),
- B(LdaConstant), U8(37),
- B(Star), R(0),
- B(LdaConstant), U8(38),
- B(Star), R(0),
- B(LdaConstant), U8(39),
- B(Star), R(0),
- B(LdaConstant), U8(40),
- B(Star), R(0),
- B(LdaConstant), U8(41),
- B(Star), R(0),
- B(LdaConstant), U8(42),
- B(Star), R(0),
- B(LdaConstant), U8(43),
- B(Star), R(0),
- B(LdaConstant), U8(44),
- B(Star), R(0),
- B(LdaConstant), U8(45),
- B(Star), R(0),
- B(LdaConstant), U8(46),
- B(Star), R(0),
- B(LdaConstant), U8(47),
- B(Star), R(0),
- B(LdaConstant), U8(48),
- B(Star), R(0),
- B(LdaConstant), U8(49),
- B(Star), R(0),
- B(LdaConstant), U8(50),
- B(Star), R(0),
- B(LdaConstant), U8(51),
- B(Star), R(0),
- B(LdaConstant), U8(52),
- B(Star), R(0),
- B(LdaConstant), U8(53),
- B(Star), R(0),
- B(LdaConstant), U8(54),
- B(Star), R(0),
- B(LdaConstant), U8(55),
- B(Star), R(0),
- B(LdaConstant), U8(56),
- B(Star), R(0),
- B(LdaConstant), U8(57),
- B(Star), R(0),
- B(LdaConstant), U8(58),
- B(Star), R(0),
- B(LdaConstant), U8(59),
- B(Star), R(0),
- B(LdaConstant), U8(60),
- B(Star), R(0),
- B(LdaConstant), U8(61),
- B(Star), R(0),
- B(LdaConstant), U8(62),
- B(Star), R(0),
- B(LdaConstant), U8(63),
- B(Star), R(0),
- B(LdaConstant), U8(64),
- B(Star), R(0),
- B(LdaConstant), U8(65),
- B(Star), R(0),
- B(LdaConstant), U8(66),
- B(Star), R(0),
- B(LdaConstant), U8(67),
- B(Star), R(0),
- B(LdaConstant), U8(68),
- B(Star), R(0),
- B(LdaConstant), U8(69),
- B(Star), R(0),
- B(LdaConstant), U8(70),
- B(Star), R(0),
- B(LdaConstant), U8(71),
- B(Star), R(0),
- B(LdaConstant), U8(72),
- B(Star), R(0),
- B(LdaConstant), U8(73),
- B(Star), R(0),
- B(LdaConstant), U8(74),
- B(Star), R(0),
- B(LdaConstant), U8(75),
- B(Star), R(0),
- B(LdaConstant), U8(76),
- B(Star), R(0),
- B(LdaConstant), U8(77),
- B(Star), R(0),
- B(LdaConstant), U8(78),
- B(Star), R(0),
- B(LdaConstant), U8(79),
- B(Star), R(0),
- B(LdaConstant), U8(80),
- B(Star), R(0),
- B(LdaConstant), U8(81),
- B(Star), R(0),
- B(LdaConstant), U8(82),
- B(Star), R(0),
- B(LdaConstant), U8(83),
- B(Star), R(0),
- B(LdaConstant), U8(84),
- B(Star), R(0),
- B(LdaConstant), U8(85),
- B(Star), R(0),
- B(LdaConstant), U8(86),
- B(Star), R(0),
- B(LdaConstant), U8(87),
- B(Star), R(0),
- B(LdaConstant), U8(88),
- B(Star), R(0),
- B(LdaConstant), U8(89),
- B(Star), R(0),
- B(LdaConstant), U8(90),
- B(Star), R(0),
- B(LdaConstant), U8(91),
- B(Star), R(0),
- B(LdaConstant), U8(92),
- B(Star), R(0),
- B(LdaConstant), U8(93),
- B(Star), R(0),
- B(LdaConstant), U8(94),
- B(Star), R(0),
- B(LdaConstant), U8(95),
- B(Star), R(0),
- B(LdaConstant), U8(96),
- B(Star), R(0),
- B(LdaConstant), U8(97),
- B(Star), R(0),
- B(LdaConstant), U8(98),
- B(Star), R(0),
- B(LdaConstant), U8(99),
- B(Star), R(0),
- B(LdaConstant), U8(100),
- B(Star), R(0),
- B(LdaConstant), U8(101),
- B(Star), R(0),
- B(LdaConstant), U8(102),
- B(Star), R(0),
- B(LdaConstant), U8(103),
- B(Star), R(0),
- B(LdaConstant), U8(104),
- B(Star), R(0),
- B(LdaConstant), U8(105),
- B(Star), R(0),
- B(LdaConstant), U8(106),
- B(Star), R(0),
- B(LdaConstant), U8(107),
- B(Star), R(0),
- B(LdaConstant), U8(108),
- B(Star), R(0),
- B(LdaConstant), U8(109),
- B(Star), R(0),
- B(LdaConstant), U8(110),
- B(Star), R(0),
- B(LdaConstant), U8(111),
- B(Star), R(0),
- B(LdaConstant), U8(112),
- B(Star), R(0),
- B(LdaConstant), U8(113),
- B(Star), R(0),
- B(LdaConstant), U8(114),
- B(Star), R(0),
- B(LdaConstant), U8(115),
- B(Star), R(0),
- B(LdaConstant), U8(116),
- B(Star), R(0),
- B(LdaConstant), U8(117),
- B(Star), R(0),
- B(LdaConstant), U8(118),
- B(Star), R(0),
- B(LdaConstant), U8(119),
- B(Star), R(0),
- B(LdaConstant), U8(120),
- B(Star), R(0),
- B(LdaConstant), U8(121),
- B(Star), R(0),
- B(LdaConstant), U8(122),
- B(Star), R(0),
- B(LdaConstant), U8(123),
- B(Star), R(0),
- B(LdaConstant), U8(124),
- B(Star), R(0),
- B(LdaConstant), U8(125),
- B(Star), R(0),
- B(LdaConstant), U8(126),
- B(Star), R(0),
- B(LdaConstant), U8(127),
- B(Star), R(0),
- B(LdaConstant), U8(128),
- B(Star), R(0),
- B(LdaConstant), U8(129),
- B(Star), R(0),
- B(LdaConstant), U8(130),
- B(Star), R(0),
- B(LdaConstant), U8(131),
- B(Star), R(0),
- B(LdaConstant), U8(132),
- B(Star), R(0),
- B(LdaConstant), U8(133),
- B(Star), R(0),
- B(LdaConstant), U8(134),
- B(Star), R(0),
- B(LdaConstant), U8(135),
- B(Star), R(0),
- B(LdaConstant), U8(136),
- B(Star), R(0),
- B(LdaConstant), U8(137),
- B(Star), R(0),
- B(LdaConstant), U8(138),
- B(Star), R(0),
- B(LdaConstant), U8(139),
- B(Star), R(0),
- B(LdaConstant), U8(140),
- B(Star), R(0),
- B(LdaConstant), U8(141),
- B(Star), R(0),
- B(LdaConstant), U8(142),
- B(Star), R(0),
- B(LdaConstant), U8(143),
- B(Star), R(0),
- B(LdaConstant), U8(144),
- B(Star), R(0),
- B(LdaConstant), U8(145),
- B(Star), R(0),
- B(LdaConstant), U8(146),
- B(Star), R(0),
- B(LdaConstant), U8(147),
- B(Star), R(0),
- B(LdaConstant), U8(148),
- B(Star), R(0),
- B(LdaConstant), U8(149),
- B(Star), R(0),
- B(LdaConstant), U8(150),
- B(Star), R(0),
- B(LdaConstant), U8(151),
- B(Star), R(0),
- B(LdaConstant), U8(152),
- B(Star), R(0),
- B(LdaConstant), U8(153),
- B(Star), R(0),
- B(LdaConstant), U8(154),
- B(Star), R(0),
- B(LdaConstant), U8(155),
- B(Star), R(0),
- B(LdaConstant), U8(156),
- B(Star), R(0),
- B(LdaConstant), U8(157),
- B(Star), R(0),
- B(LdaConstant), U8(158),
- B(Star), R(0),
- B(LdaConstant), U8(159),
- B(Star), R(0),
- B(LdaConstant), U8(160),
- B(Star), R(0),
- B(LdaConstant), U8(161),
- B(Star), R(0),
- B(LdaConstant), U8(162),
- B(Star), R(0),
- B(LdaConstant), U8(163),
- B(Star), R(0),
- B(LdaConstant), U8(164),
- B(Star), R(0),
- B(LdaConstant), U8(165),
- B(Star), R(0),
- B(LdaConstant), U8(166),
- B(Star), R(0),
- B(LdaConstant), U8(167),
- B(Star), R(0),
- B(LdaConstant), U8(168),
- B(Star), R(0),
- B(LdaConstant), U8(169),
- B(Star), R(0),
- B(LdaConstant), U8(170),
- B(Star), R(0),
- B(LdaConstant), U8(171),
- B(Star), R(0),
- B(LdaConstant), U8(172),
- B(Star), R(0),
- B(LdaConstant), U8(173),
- B(Star), R(0),
- B(LdaConstant), U8(174),
- B(Star), R(0),
- B(LdaConstant), U8(175),
- B(Star), R(0),
- B(LdaConstant), U8(176),
- B(Star), R(0),
- B(LdaConstant), U8(177),
- B(Star), R(0),
- B(LdaConstant), U8(178),
- B(Star), R(0),
- B(LdaConstant), U8(179),
- B(Star), R(0),
- B(LdaConstant), U8(180),
- B(Star), R(0),
- B(LdaConstant), U8(181),
- B(Star), R(0),
- B(LdaConstant), U8(182),
- B(Star), R(0),
- B(LdaConstant), U8(183),
- B(Star), R(0),
- B(LdaConstant), U8(184),
- B(Star), R(0),
- B(LdaConstant), U8(185),
- B(Star), R(0),
- B(LdaConstant), U8(186),
- B(Star), R(0),
- B(LdaConstant), U8(187),
- B(Star), R(0),
- B(LdaConstant), U8(188),
- B(Star), R(0),
- B(LdaConstant), U8(189),
- B(Star), R(0),
- B(LdaConstant), U8(190),
- B(Star), R(0),
- B(LdaConstant), U8(191),
- B(Star), R(0),
- B(LdaConstant), U8(192),
- B(Star), R(0),
- B(LdaConstant), U8(193),
- B(Star), R(0),
- B(LdaConstant), U8(194),
- B(Star), R(0),
- B(LdaConstant), U8(195),
- B(Star), R(0),
- B(LdaConstant), U8(196),
- B(Star), R(0),
- B(LdaConstant), U8(197),
- B(Star), R(0),
- B(LdaConstant), U8(198),
- B(Star), R(0),
- B(LdaConstant), U8(199),
- B(Star), R(0),
- B(LdaConstant), U8(200),
- B(Star), R(0),
- B(LdaConstant), U8(201),
- B(Star), R(0),
- B(LdaConstant), U8(202),
- B(Star), R(0),
- B(LdaConstant), U8(203),
- B(Star), R(0),
- B(LdaConstant), U8(204),
- B(Star), R(0),
- B(LdaConstant), U8(205),
- B(Star), R(0),
- B(LdaConstant), U8(206),
- B(Star), R(0),
- B(LdaConstant), U8(207),
- B(Star), R(0),
- B(LdaConstant), U8(208),
- B(Star), R(0),
- B(LdaConstant), U8(209),
- B(Star), R(0),
- B(LdaConstant), U8(210),
- B(Star), R(0),
- B(LdaConstant), U8(211),
- B(Star), R(0),
- B(LdaConstant), U8(212),
- B(Star), R(0),
- B(LdaConstant), U8(213),
- B(Star), R(0),
- B(LdaConstant), U8(214),
- B(Star), R(0),
- B(LdaConstant), U8(215),
- B(Star), R(0),
- B(LdaConstant), U8(216),
- B(Star), R(0),
- B(LdaConstant), U8(217),
- B(Star), R(0),
- B(LdaConstant), U8(218),
- B(Star), R(0),
- B(LdaConstant), U8(219),
- B(Star), R(0),
- B(LdaConstant), U8(220),
- B(Star), R(0),
- B(LdaConstant), U8(221),
- B(Star), R(0),
- B(LdaConstant), U8(222),
- B(Star), R(0),
- B(LdaConstant), U8(223),
- B(Star), R(0),
- B(LdaConstant), U8(224),
- B(Star), R(0),
- B(LdaConstant), U8(225),
- B(Star), R(0),
- B(LdaConstant), U8(226),
- B(Star), R(0),
- B(LdaConstant), U8(227),
- B(Star), R(0),
- B(LdaConstant), U8(228),
- B(Star), R(0),
- B(LdaConstant), U8(229),
- B(Star), R(0),
- B(LdaConstant), U8(230),
- B(Star), R(0),
- B(LdaConstant), U8(231),
- B(Star), R(0),
- B(LdaConstant), U8(232),
- B(Star), R(0),
- B(LdaConstant), U8(233),
- B(Star), R(0),
- B(LdaConstant), U8(234),
- B(Star), R(0),
- B(LdaConstant), U8(235),
- B(Star), R(0),
- B(LdaConstant), U8(236),
- B(Star), R(0),
- B(LdaConstant), U8(237),
- B(Star), R(0),
- B(LdaConstant), U8(238),
- B(Star), R(0),
- B(LdaConstant), U8(239),
- B(Star), R(0),
- B(LdaConstant), U8(240),
- B(Star), R(0),
- B(LdaConstant), U8(241),
- B(Star), R(0),
- B(LdaConstant), U8(242),
- B(Star), R(0),
- B(LdaConstant), U8(243),
- B(Star), R(0),
- B(LdaConstant), U8(244),
- B(Star), R(0),
- B(LdaConstant), U8(245),
- B(Star), R(0),
- B(LdaConstant), U8(246),
- B(Star), R(0),
- B(LdaConstant), U8(247),
- B(Star), R(0),
- B(LdaConstant), U8(248),
- B(Star), R(0),
- B(LdaConstant), U8(249),
- B(Star), R(0),
- B(LdaConstant), U8(250),
- B(Star), R(0),
- B(LdaConstant), U8(251),
- B(Star), R(0),
- B(LdaConstant), U8(252),
- B(Star), R(0),
- B(LdaConstant), U8(253),
- B(Star), R(0),
- B(LdaConstant), U8(254),
- B(Star), R(0),
- B(LdaConstant), U8(255),
- B(Star), R(0),
- B(LdaSmi), U8(10),
- B(Wide), B(StaLookupSlotSloppy), U16(256),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 22 S> */ B(LdaConstant), U8(0),
+ /* 22 E> */ B(Star), R(0),
+ /* 34 S> */ B(LdaConstant), U8(1),
+ /* 34 E> */ B(Star), R(0),
+ /* 46 S> */ B(LdaConstant), U8(2),
+ /* 46 E> */ B(Star), R(0),
+ /* 58 S> */ B(LdaConstant), U8(3),
+ /* 58 E> */ B(Star), R(0),
+ /* 70 S> */ B(LdaConstant), U8(4),
+ /* 70 E> */ B(Star), R(0),
+ /* 82 S> */ B(LdaConstant), U8(5),
+ /* 82 E> */ B(Star), R(0),
+ /* 94 S> */ B(LdaConstant), U8(6),
+ /* 94 E> */ B(Star), R(0),
+ /* 106 S> */ B(LdaConstant), U8(7),
+ /* 106 E> */ B(Star), R(0),
+ /* 118 S> */ B(LdaConstant), U8(8),
+ /* 118 E> */ B(Star), R(0),
+ /* 130 S> */ B(LdaConstant), U8(9),
+ /* 130 E> */ B(Star), R(0),
+ /* 142 S> */ B(LdaConstant), U8(10),
+ /* 142 E> */ B(Star), R(0),
+ /* 154 S> */ B(LdaConstant), U8(11),
+ /* 154 E> */ B(Star), R(0),
+ /* 166 S> */ B(LdaConstant), U8(12),
+ /* 166 E> */ B(Star), R(0),
+ /* 178 S> */ B(LdaConstant), U8(13),
+ /* 178 E> */ B(Star), R(0),
+ /* 190 S> */ B(LdaConstant), U8(14),
+ /* 190 E> */ B(Star), R(0),
+ /* 202 S> */ B(LdaConstant), U8(15),
+ /* 202 E> */ B(Star), R(0),
+ /* 214 S> */ B(LdaConstant), U8(16),
+ /* 214 E> */ B(Star), R(0),
+ /* 226 S> */ B(LdaConstant), U8(17),
+ /* 226 E> */ B(Star), R(0),
+ /* 238 S> */ B(LdaConstant), U8(18),
+ /* 238 E> */ B(Star), R(0),
+ /* 250 S> */ B(LdaConstant), U8(19),
+ /* 250 E> */ B(Star), R(0),
+ /* 262 S> */ B(LdaConstant), U8(20),
+ /* 262 E> */ B(Star), R(0),
+ /* 274 S> */ B(LdaConstant), U8(21),
+ /* 274 E> */ B(Star), R(0),
+ /* 286 S> */ B(LdaConstant), U8(22),
+ /* 286 E> */ B(Star), R(0),
+ /* 298 S> */ B(LdaConstant), U8(23),
+ /* 298 E> */ B(Star), R(0),
+ /* 310 S> */ B(LdaConstant), U8(24),
+ /* 310 E> */ B(Star), R(0),
+ /* 322 S> */ B(LdaConstant), U8(25),
+ /* 322 E> */ B(Star), R(0),
+ /* 334 S> */ B(LdaConstant), U8(26),
+ /* 334 E> */ B(Star), R(0),
+ /* 346 S> */ B(LdaConstant), U8(27),
+ /* 346 E> */ B(Star), R(0),
+ /* 358 S> */ B(LdaConstant), U8(28),
+ /* 358 E> */ B(Star), R(0),
+ /* 370 S> */ B(LdaConstant), U8(29),
+ /* 370 E> */ B(Star), R(0),
+ /* 382 S> */ B(LdaConstant), U8(30),
+ /* 382 E> */ B(Star), R(0),
+ /* 394 S> */ B(LdaConstant), U8(31),
+ /* 394 E> */ B(Star), R(0),
+ /* 406 S> */ B(LdaConstant), U8(32),
+ /* 406 E> */ B(Star), R(0),
+ /* 418 S> */ B(LdaConstant), U8(33),
+ /* 418 E> */ B(Star), R(0),
+ /* 430 S> */ B(LdaConstant), U8(34),
+ /* 430 E> */ B(Star), R(0),
+ /* 442 S> */ B(LdaConstant), U8(35),
+ /* 442 E> */ B(Star), R(0),
+ /* 454 S> */ B(LdaConstant), U8(36),
+ /* 454 E> */ B(Star), R(0),
+ /* 466 S> */ B(LdaConstant), U8(37),
+ /* 466 E> */ B(Star), R(0),
+ /* 478 S> */ B(LdaConstant), U8(38),
+ /* 478 E> */ B(Star), R(0),
+ /* 490 S> */ B(LdaConstant), U8(39),
+ /* 490 E> */ B(Star), R(0),
+ /* 502 S> */ B(LdaConstant), U8(40),
+ /* 502 E> */ B(Star), R(0),
+ /* 514 S> */ B(LdaConstant), U8(41),
+ /* 514 E> */ B(Star), R(0),
+ /* 526 S> */ B(LdaConstant), U8(42),
+ /* 526 E> */ B(Star), R(0),
+ /* 538 S> */ B(LdaConstant), U8(43),
+ /* 538 E> */ B(Star), R(0),
+ /* 550 S> */ B(LdaConstant), U8(44),
+ /* 550 E> */ B(Star), R(0),
+ /* 562 S> */ B(LdaConstant), U8(45),
+ /* 562 E> */ B(Star), R(0),
+ /* 574 S> */ B(LdaConstant), U8(46),
+ /* 574 E> */ B(Star), R(0),
+ /* 586 S> */ B(LdaConstant), U8(47),
+ /* 586 E> */ B(Star), R(0),
+ /* 598 S> */ B(LdaConstant), U8(48),
+ /* 598 E> */ B(Star), R(0),
+ /* 610 S> */ B(LdaConstant), U8(49),
+ /* 610 E> */ B(Star), R(0),
+ /* 622 S> */ B(LdaConstant), U8(50),
+ /* 622 E> */ B(Star), R(0),
+ /* 634 S> */ B(LdaConstant), U8(51),
+ /* 634 E> */ B(Star), R(0),
+ /* 646 S> */ B(LdaConstant), U8(52),
+ /* 646 E> */ B(Star), R(0),
+ /* 658 S> */ B(LdaConstant), U8(53),
+ /* 658 E> */ B(Star), R(0),
+ /* 670 S> */ B(LdaConstant), U8(54),
+ /* 670 E> */ B(Star), R(0),
+ /* 682 S> */ B(LdaConstant), U8(55),
+ /* 682 E> */ B(Star), R(0),
+ /* 694 S> */ B(LdaConstant), U8(56),
+ /* 694 E> */ B(Star), R(0),
+ /* 706 S> */ B(LdaConstant), U8(57),
+ /* 706 E> */ B(Star), R(0),
+ /* 718 S> */ B(LdaConstant), U8(58),
+ /* 718 E> */ B(Star), R(0),
+ /* 730 S> */ B(LdaConstant), U8(59),
+ /* 730 E> */ B(Star), R(0),
+ /* 742 S> */ B(LdaConstant), U8(60),
+ /* 742 E> */ B(Star), R(0),
+ /* 754 S> */ B(LdaConstant), U8(61),
+ /* 754 E> */ B(Star), R(0),
+ /* 766 S> */ B(LdaConstant), U8(62),
+ /* 766 E> */ B(Star), R(0),
+ /* 778 S> */ B(LdaConstant), U8(63),
+ /* 778 E> */ B(Star), R(0),
+ /* 790 S> */ B(LdaConstant), U8(64),
+ /* 790 E> */ B(Star), R(0),
+ /* 802 S> */ B(LdaConstant), U8(65),
+ /* 802 E> */ B(Star), R(0),
+ /* 814 S> */ B(LdaConstant), U8(66),
+ /* 814 E> */ B(Star), R(0),
+ /* 826 S> */ B(LdaConstant), U8(67),
+ /* 826 E> */ B(Star), R(0),
+ /* 838 S> */ B(LdaConstant), U8(68),
+ /* 838 E> */ B(Star), R(0),
+ /* 850 S> */ B(LdaConstant), U8(69),
+ /* 850 E> */ B(Star), R(0),
+ /* 862 S> */ B(LdaConstant), U8(70),
+ /* 862 E> */ B(Star), R(0),
+ /* 874 S> */ B(LdaConstant), U8(71),
+ /* 874 E> */ B(Star), R(0),
+ /* 886 S> */ B(LdaConstant), U8(72),
+ /* 886 E> */ B(Star), R(0),
+ /* 898 S> */ B(LdaConstant), U8(73),
+ /* 898 E> */ B(Star), R(0),
+ /* 910 S> */ B(LdaConstant), U8(74),
+ /* 910 E> */ B(Star), R(0),
+ /* 922 S> */ B(LdaConstant), U8(75),
+ /* 922 E> */ B(Star), R(0),
+ /* 934 S> */ B(LdaConstant), U8(76),
+ /* 934 E> */ B(Star), R(0),
+ /* 946 S> */ B(LdaConstant), U8(77),
+ /* 946 E> */ B(Star), R(0),
+ /* 958 S> */ B(LdaConstant), U8(78),
+ /* 958 E> */ B(Star), R(0),
+ /* 970 S> */ B(LdaConstant), U8(79),
+ /* 970 E> */ B(Star), R(0),
+ /* 982 S> */ B(LdaConstant), U8(80),
+ /* 982 E> */ B(Star), R(0),
+ /* 994 S> */ B(LdaConstant), U8(81),
+ /* 994 E> */ B(Star), R(0),
+ /* 1006 S> */ B(LdaConstant), U8(82),
+ /* 1006 E> */ B(Star), R(0),
+ /* 1018 S> */ B(LdaConstant), U8(83),
+ /* 1018 E> */ B(Star), R(0),
+ /* 1030 S> */ B(LdaConstant), U8(84),
+ /* 1030 E> */ B(Star), R(0),
+ /* 1042 S> */ B(LdaConstant), U8(85),
+ /* 1042 E> */ B(Star), R(0),
+ /* 1054 S> */ B(LdaConstant), U8(86),
+ /* 1054 E> */ B(Star), R(0),
+ /* 1066 S> */ B(LdaConstant), U8(87),
+ /* 1066 E> */ B(Star), R(0),
+ /* 1078 S> */ B(LdaConstant), U8(88),
+ /* 1078 E> */ B(Star), R(0),
+ /* 1090 S> */ B(LdaConstant), U8(89),
+ /* 1090 E> */ B(Star), R(0),
+ /* 1102 S> */ B(LdaConstant), U8(90),
+ /* 1102 E> */ B(Star), R(0),
+ /* 1114 S> */ B(LdaConstant), U8(91),
+ /* 1114 E> */ B(Star), R(0),
+ /* 1126 S> */ B(LdaConstant), U8(92),
+ /* 1126 E> */ B(Star), R(0),
+ /* 1138 S> */ B(LdaConstant), U8(93),
+ /* 1138 E> */ B(Star), R(0),
+ /* 1150 S> */ B(LdaConstant), U8(94),
+ /* 1150 E> */ B(Star), R(0),
+ /* 1162 S> */ B(LdaConstant), U8(95),
+ /* 1162 E> */ B(Star), R(0),
+ /* 1174 S> */ B(LdaConstant), U8(96),
+ /* 1174 E> */ B(Star), R(0),
+ /* 1186 S> */ B(LdaConstant), U8(97),
+ /* 1186 E> */ B(Star), R(0),
+ /* 1198 S> */ B(LdaConstant), U8(98),
+ /* 1198 E> */ B(Star), R(0),
+ /* 1210 S> */ B(LdaConstant), U8(99),
+ /* 1210 E> */ B(Star), R(0),
+ /* 1222 S> */ B(LdaConstant), U8(100),
+ /* 1222 E> */ B(Star), R(0),
+ /* 1234 S> */ B(LdaConstant), U8(101),
+ /* 1234 E> */ B(Star), R(0),
+ /* 1246 S> */ B(LdaConstant), U8(102),
+ /* 1246 E> */ B(Star), R(0),
+ /* 1258 S> */ B(LdaConstant), U8(103),
+ /* 1258 E> */ B(Star), R(0),
+ /* 1270 S> */ B(LdaConstant), U8(104),
+ /* 1270 E> */ B(Star), R(0),
+ /* 1282 S> */ B(LdaConstant), U8(105),
+ /* 1282 E> */ B(Star), R(0),
+ /* 1294 S> */ B(LdaConstant), U8(106),
+ /* 1294 E> */ B(Star), R(0),
+ /* 1306 S> */ B(LdaConstant), U8(107),
+ /* 1306 E> */ B(Star), R(0),
+ /* 1318 S> */ B(LdaConstant), U8(108),
+ /* 1318 E> */ B(Star), R(0),
+ /* 1330 S> */ B(LdaConstant), U8(109),
+ /* 1330 E> */ B(Star), R(0),
+ /* 1342 S> */ B(LdaConstant), U8(110),
+ /* 1342 E> */ B(Star), R(0),
+ /* 1354 S> */ B(LdaConstant), U8(111),
+ /* 1354 E> */ B(Star), R(0),
+ /* 1366 S> */ B(LdaConstant), U8(112),
+ /* 1366 E> */ B(Star), R(0),
+ /* 1378 S> */ B(LdaConstant), U8(113),
+ /* 1378 E> */ B(Star), R(0),
+ /* 1390 S> */ B(LdaConstant), U8(114),
+ /* 1390 E> */ B(Star), R(0),
+ /* 1402 S> */ B(LdaConstant), U8(115),
+ /* 1402 E> */ B(Star), R(0),
+ /* 1414 S> */ B(LdaConstant), U8(116),
+ /* 1414 E> */ B(Star), R(0),
+ /* 1426 S> */ B(LdaConstant), U8(117),
+ /* 1426 E> */ B(Star), R(0),
+ /* 1438 S> */ B(LdaConstant), U8(118),
+ /* 1438 E> */ B(Star), R(0),
+ /* 1450 S> */ B(LdaConstant), U8(119),
+ /* 1450 E> */ B(Star), R(0),
+ /* 1462 S> */ B(LdaConstant), U8(120),
+ /* 1462 E> */ B(Star), R(0),
+ /* 1474 S> */ B(LdaConstant), U8(121),
+ /* 1474 E> */ B(Star), R(0),
+ /* 1486 S> */ B(LdaConstant), U8(122),
+ /* 1486 E> */ B(Star), R(0),
+ /* 1498 S> */ B(LdaConstant), U8(123),
+ /* 1498 E> */ B(Star), R(0),
+ /* 1510 S> */ B(LdaConstant), U8(124),
+ /* 1510 E> */ B(Star), R(0),
+ /* 1522 S> */ B(LdaConstant), U8(125),
+ /* 1522 E> */ B(Star), R(0),
+ /* 1534 S> */ B(LdaConstant), U8(126),
+ /* 1534 E> */ B(Star), R(0),
+ /* 1546 S> */ B(LdaConstant), U8(127),
+ /* 1546 E> */ B(Star), R(0),
+ /* 1558 S> */ B(LdaConstant), U8(128),
+ /* 1558 E> */ B(Star), R(0),
+ /* 1570 S> */ B(LdaConstant), U8(129),
+ /* 1570 E> */ B(Star), R(0),
+ /* 1582 S> */ B(LdaConstant), U8(130),
+ /* 1582 E> */ B(Star), R(0),
+ /* 1594 S> */ B(LdaConstant), U8(131),
+ /* 1594 E> */ B(Star), R(0),
+ /* 1606 S> */ B(LdaConstant), U8(132),
+ /* 1606 E> */ B(Star), R(0),
+ /* 1618 S> */ B(LdaConstant), U8(133),
+ /* 1618 E> */ B(Star), R(0),
+ /* 1630 S> */ B(LdaConstant), U8(134),
+ /* 1630 E> */ B(Star), R(0),
+ /* 1642 S> */ B(LdaConstant), U8(135),
+ /* 1642 E> */ B(Star), R(0),
+ /* 1654 S> */ B(LdaConstant), U8(136),
+ /* 1654 E> */ B(Star), R(0),
+ /* 1666 S> */ B(LdaConstant), U8(137),
+ /* 1666 E> */ B(Star), R(0),
+ /* 1678 S> */ B(LdaConstant), U8(138),
+ /* 1678 E> */ B(Star), R(0),
+ /* 1690 S> */ B(LdaConstant), U8(139),
+ /* 1690 E> */ B(Star), R(0),
+ /* 1702 S> */ B(LdaConstant), U8(140),
+ /* 1702 E> */ B(Star), R(0),
+ /* 1714 S> */ B(LdaConstant), U8(141),
+ /* 1714 E> */ B(Star), R(0),
+ /* 1726 S> */ B(LdaConstant), U8(142),
+ /* 1726 E> */ B(Star), R(0),
+ /* 1738 S> */ B(LdaConstant), U8(143),
+ /* 1738 E> */ B(Star), R(0),
+ /* 1750 S> */ B(LdaConstant), U8(144),
+ /* 1750 E> */ B(Star), R(0),
+ /* 1762 S> */ B(LdaConstant), U8(145),
+ /* 1762 E> */ B(Star), R(0),
+ /* 1774 S> */ B(LdaConstant), U8(146),
+ /* 1774 E> */ B(Star), R(0),
+ /* 1786 S> */ B(LdaConstant), U8(147),
+ /* 1786 E> */ B(Star), R(0),
+ /* 1798 S> */ B(LdaConstant), U8(148),
+ /* 1798 E> */ B(Star), R(0),
+ /* 1810 S> */ B(LdaConstant), U8(149),
+ /* 1810 E> */ B(Star), R(0),
+ /* 1822 S> */ B(LdaConstant), U8(150),
+ /* 1822 E> */ B(Star), R(0),
+ /* 1834 S> */ B(LdaConstant), U8(151),
+ /* 1834 E> */ B(Star), R(0),
+ /* 1846 S> */ B(LdaConstant), U8(152),
+ /* 1846 E> */ B(Star), R(0),
+ /* 1858 S> */ B(LdaConstant), U8(153),
+ /* 1858 E> */ B(Star), R(0),
+ /* 1870 S> */ B(LdaConstant), U8(154),
+ /* 1870 E> */ B(Star), R(0),
+ /* 1882 S> */ B(LdaConstant), U8(155),
+ /* 1882 E> */ B(Star), R(0),
+ /* 1894 S> */ B(LdaConstant), U8(156),
+ /* 1894 E> */ B(Star), R(0),
+ /* 1906 S> */ B(LdaConstant), U8(157),
+ /* 1906 E> */ B(Star), R(0),
+ /* 1918 S> */ B(LdaConstant), U8(158),
+ /* 1918 E> */ B(Star), R(0),
+ /* 1930 S> */ B(LdaConstant), U8(159),
+ /* 1930 E> */ B(Star), R(0),
+ /* 1942 S> */ B(LdaConstant), U8(160),
+ /* 1942 E> */ B(Star), R(0),
+ /* 1954 S> */ B(LdaConstant), U8(161),
+ /* 1954 E> */ B(Star), R(0),
+ /* 1966 S> */ B(LdaConstant), U8(162),
+ /* 1966 E> */ B(Star), R(0),
+ /* 1978 S> */ B(LdaConstant), U8(163),
+ /* 1978 E> */ B(Star), R(0),
+ /* 1990 S> */ B(LdaConstant), U8(164),
+ /* 1990 E> */ B(Star), R(0),
+ /* 2002 S> */ B(LdaConstant), U8(165),
+ /* 2002 E> */ B(Star), R(0),
+ /* 2014 S> */ B(LdaConstant), U8(166),
+ /* 2014 E> */ B(Star), R(0),
+ /* 2026 S> */ B(LdaConstant), U8(167),
+ /* 2026 E> */ B(Star), R(0),
+ /* 2038 S> */ B(LdaConstant), U8(168),
+ /* 2038 E> */ B(Star), R(0),
+ /* 2050 S> */ B(LdaConstant), U8(169),
+ /* 2050 E> */ B(Star), R(0),
+ /* 2062 S> */ B(LdaConstant), U8(170),
+ /* 2062 E> */ B(Star), R(0),
+ /* 2074 S> */ B(LdaConstant), U8(171),
+ /* 2074 E> */ B(Star), R(0),
+ /* 2086 S> */ B(LdaConstant), U8(172),
+ /* 2086 E> */ B(Star), R(0),
+ /* 2098 S> */ B(LdaConstant), U8(173),
+ /* 2098 E> */ B(Star), R(0),
+ /* 2110 S> */ B(LdaConstant), U8(174),
+ /* 2110 E> */ B(Star), R(0),
+ /* 2122 S> */ B(LdaConstant), U8(175),
+ /* 2122 E> */ B(Star), R(0),
+ /* 2134 S> */ B(LdaConstant), U8(176),
+ /* 2134 E> */ B(Star), R(0),
+ /* 2146 S> */ B(LdaConstant), U8(177),
+ /* 2146 E> */ B(Star), R(0),
+ /* 2158 S> */ B(LdaConstant), U8(178),
+ /* 2158 E> */ B(Star), R(0),
+ /* 2170 S> */ B(LdaConstant), U8(179),
+ /* 2170 E> */ B(Star), R(0),
+ /* 2182 S> */ B(LdaConstant), U8(180),
+ /* 2182 E> */ B(Star), R(0),
+ /* 2194 S> */ B(LdaConstant), U8(181),
+ /* 2194 E> */ B(Star), R(0),
+ /* 2206 S> */ B(LdaConstant), U8(182),
+ /* 2206 E> */ B(Star), R(0),
+ /* 2218 S> */ B(LdaConstant), U8(183),
+ /* 2218 E> */ B(Star), R(0),
+ /* 2230 S> */ B(LdaConstant), U8(184),
+ /* 2230 E> */ B(Star), R(0),
+ /* 2242 S> */ B(LdaConstant), U8(185),
+ /* 2242 E> */ B(Star), R(0),
+ /* 2254 S> */ B(LdaConstant), U8(186),
+ /* 2254 E> */ B(Star), R(0),
+ /* 2266 S> */ B(LdaConstant), U8(187),
+ /* 2266 E> */ B(Star), R(0),
+ /* 2278 S> */ B(LdaConstant), U8(188),
+ /* 2278 E> */ B(Star), R(0),
+ /* 2290 S> */ B(LdaConstant), U8(189),
+ /* 2290 E> */ B(Star), R(0),
+ /* 2302 S> */ B(LdaConstant), U8(190),
+ /* 2302 E> */ B(Star), R(0),
+ /* 2314 S> */ B(LdaConstant), U8(191),
+ /* 2314 E> */ B(Star), R(0),
+ /* 2326 S> */ B(LdaConstant), U8(192),
+ /* 2326 E> */ B(Star), R(0),
+ /* 2338 S> */ B(LdaConstant), U8(193),
+ /* 2338 E> */ B(Star), R(0),
+ /* 2350 S> */ B(LdaConstant), U8(194),
+ /* 2350 E> */ B(Star), R(0),
+ /* 2362 S> */ B(LdaConstant), U8(195),
+ /* 2362 E> */ B(Star), R(0),
+ /* 2374 S> */ B(LdaConstant), U8(196),
+ /* 2374 E> */ B(Star), R(0),
+ /* 2386 S> */ B(LdaConstant), U8(197),
+ /* 2386 E> */ B(Star), R(0),
+ /* 2398 S> */ B(LdaConstant), U8(198),
+ /* 2398 E> */ B(Star), R(0),
+ /* 2410 S> */ B(LdaConstant), U8(199),
+ /* 2410 E> */ B(Star), R(0),
+ /* 2422 S> */ B(LdaConstant), U8(200),
+ /* 2422 E> */ B(Star), R(0),
+ /* 2434 S> */ B(LdaConstant), U8(201),
+ /* 2434 E> */ B(Star), R(0),
+ /* 2446 S> */ B(LdaConstant), U8(202),
+ /* 2446 E> */ B(Star), R(0),
+ /* 2458 S> */ B(LdaConstant), U8(203),
+ /* 2458 E> */ B(Star), R(0),
+ /* 2470 S> */ B(LdaConstant), U8(204),
+ /* 2470 E> */ B(Star), R(0),
+ /* 2482 S> */ B(LdaConstant), U8(205),
+ /* 2482 E> */ B(Star), R(0),
+ /* 2494 S> */ B(LdaConstant), U8(206),
+ /* 2494 E> */ B(Star), R(0),
+ /* 2506 S> */ B(LdaConstant), U8(207),
+ /* 2506 E> */ B(Star), R(0),
+ /* 2518 S> */ B(LdaConstant), U8(208),
+ /* 2518 E> */ B(Star), R(0),
+ /* 2530 S> */ B(LdaConstant), U8(209),
+ /* 2530 E> */ B(Star), R(0),
+ /* 2542 S> */ B(LdaConstant), U8(210),
+ /* 2542 E> */ B(Star), R(0),
+ /* 2554 S> */ B(LdaConstant), U8(211),
+ /* 2554 E> */ B(Star), R(0),
+ /* 2566 S> */ B(LdaConstant), U8(212),
+ /* 2566 E> */ B(Star), R(0),
+ /* 2578 S> */ B(LdaConstant), U8(213),
+ /* 2578 E> */ B(Star), R(0),
+ /* 2590 S> */ B(LdaConstant), U8(214),
+ /* 2590 E> */ B(Star), R(0),
+ /* 2602 S> */ B(LdaConstant), U8(215),
+ /* 2602 E> */ B(Star), R(0),
+ /* 2614 S> */ B(LdaConstant), U8(216),
+ /* 2614 E> */ B(Star), R(0),
+ /* 2626 S> */ B(LdaConstant), U8(217),
+ /* 2626 E> */ B(Star), R(0),
+ /* 2638 S> */ B(LdaConstant), U8(218),
+ /* 2638 E> */ B(Star), R(0),
+ /* 2650 S> */ B(LdaConstant), U8(219),
+ /* 2650 E> */ B(Star), R(0),
+ /* 2662 S> */ B(LdaConstant), U8(220),
+ /* 2662 E> */ B(Star), R(0),
+ /* 2674 S> */ B(LdaConstant), U8(221),
+ /* 2674 E> */ B(Star), R(0),
+ /* 2686 S> */ B(LdaConstant), U8(222),
+ /* 2686 E> */ B(Star), R(0),
+ /* 2698 S> */ B(LdaConstant), U8(223),
+ /* 2698 E> */ B(Star), R(0),
+ /* 2710 S> */ B(LdaConstant), U8(224),
+ /* 2710 E> */ B(Star), R(0),
+ /* 2722 S> */ B(LdaConstant), U8(225),
+ /* 2722 E> */ B(Star), R(0),
+ /* 2734 S> */ B(LdaConstant), U8(226),
+ /* 2734 E> */ B(Star), R(0),
+ /* 2746 S> */ B(LdaConstant), U8(227),
+ /* 2746 E> */ B(Star), R(0),
+ /* 2758 S> */ B(LdaConstant), U8(228),
+ /* 2758 E> */ B(Star), R(0),
+ /* 2770 S> */ B(LdaConstant), U8(229),
+ /* 2770 E> */ B(Star), R(0),
+ /* 2782 S> */ B(LdaConstant), U8(230),
+ /* 2782 E> */ B(Star), R(0),
+ /* 2794 S> */ B(LdaConstant), U8(231),
+ /* 2794 E> */ B(Star), R(0),
+ /* 2806 S> */ B(LdaConstant), U8(232),
+ /* 2806 E> */ B(Star), R(0),
+ /* 2818 S> */ B(LdaConstant), U8(233),
+ /* 2818 E> */ B(Star), R(0),
+ /* 2830 S> */ B(LdaConstant), U8(234),
+ /* 2830 E> */ B(Star), R(0),
+ /* 2842 S> */ B(LdaConstant), U8(235),
+ /* 2842 E> */ B(Star), R(0),
+ /* 2854 S> */ B(LdaConstant), U8(236),
+ /* 2854 E> */ B(Star), R(0),
+ /* 2866 S> */ B(LdaConstant), U8(237),
+ /* 2866 E> */ B(Star), R(0),
+ /* 2878 S> */ B(LdaConstant), U8(238),
+ /* 2878 E> */ B(Star), R(0),
+ /* 2890 S> */ B(LdaConstant), U8(239),
+ /* 2890 E> */ B(Star), R(0),
+ /* 2902 S> */ B(LdaConstant), U8(240),
+ /* 2902 E> */ B(Star), R(0),
+ /* 2914 S> */ B(LdaConstant), U8(241),
+ /* 2914 E> */ B(Star), R(0),
+ /* 2926 S> */ B(LdaConstant), U8(242),
+ /* 2926 E> */ B(Star), R(0),
+ /* 2938 S> */ B(LdaConstant), U8(243),
+ /* 2938 E> */ B(Star), R(0),
+ /* 2950 S> */ B(LdaConstant), U8(244),
+ /* 2950 E> */ B(Star), R(0),
+ /* 2962 S> */ B(LdaConstant), U8(245),
+ /* 2962 E> */ B(Star), R(0),
+ /* 2974 S> */ B(LdaConstant), U8(246),
+ /* 2974 E> */ B(Star), R(0),
+ /* 2986 S> */ B(LdaConstant), U8(247),
+ /* 2986 E> */ B(Star), R(0),
+ /* 2998 S> */ B(LdaConstant), U8(248),
+ /* 2998 E> */ B(Star), R(0),
+ /* 3010 S> */ B(LdaConstant), U8(249),
+ /* 3010 E> */ B(Star), R(0),
+ /* 3022 S> */ B(LdaConstant), U8(250),
+ /* 3022 E> */ B(Star), R(0),
+ /* 3034 S> */ B(LdaConstant), U8(251),
+ /* 3034 E> */ B(Star), R(0),
+ /* 3046 S> */ B(LdaConstant), U8(252),
+ /* 3046 E> */ B(Star), R(0),
+ /* 3058 S> */ B(LdaConstant), U8(253),
+ /* 3058 E> */ B(Star), R(0),
+ /* 3070 S> */ B(LdaConstant), U8(254),
+ /* 3070 E> */ B(Star), R(0),
+ /* 3082 S> */ B(LdaConstant), U8(255),
+ /* 3082 E> */ B(Star), R(0),
+ /* 3086 S> */ B(LdaSmi), U8(10),
+ /* 3088 E> */ B(Wide), B(StaLookupSlotSloppy), U16(256),
+ B(LdaUndefined),
+ /* 3093 S> */ B(Return),
]
constant pool: [
InstanceType::HEAP_NUMBER_TYPE,
@@ -3438,523 +3438,523 @@
parameter count: 1
bytecode array length: 1033
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(2),
- B(Star), R(0),
- B(LdaConstant), U8(3),
- B(Star), R(0),
- B(LdaConstant), U8(4),
- B(Star), R(0),
- B(LdaConstant), U8(5),
- B(Star), R(0),
- B(LdaConstant), U8(6),
- B(Star), R(0),
- B(LdaConstant), U8(7),
- B(Star), R(0),
- B(LdaConstant), U8(8),
- B(Star), R(0),
- B(LdaConstant), U8(9),
- B(Star), R(0),
- B(LdaConstant), U8(10),
- B(Star), R(0),
- B(LdaConstant), U8(11),
- B(Star), R(0),
- B(LdaConstant), U8(12),
- B(Star), R(0),
- B(LdaConstant), U8(13),
- B(Star), R(0),
- B(LdaConstant), U8(14),
- B(Star), R(0),
- B(LdaConstant), U8(15),
- B(Star), R(0),
- B(LdaConstant), U8(16),
- B(Star), R(0),
- B(LdaConstant), U8(17),
- B(Star), R(0),
- B(LdaConstant), U8(18),
- B(Star), R(0),
- B(LdaConstant), U8(19),
- B(Star), R(0),
- B(LdaConstant), U8(20),
- B(Star), R(0),
- B(LdaConstant), U8(21),
- B(Star), R(0),
- B(LdaConstant), U8(22),
- B(Star), R(0),
- B(LdaConstant), U8(23),
- B(Star), R(0),
- B(LdaConstant), U8(24),
- B(Star), R(0),
- B(LdaConstant), U8(25),
- B(Star), R(0),
- B(LdaConstant), U8(26),
- B(Star), R(0),
- B(LdaConstant), U8(27),
- B(Star), R(0),
- B(LdaConstant), U8(28),
- B(Star), R(0),
- B(LdaConstant), U8(29),
- B(Star), R(0),
- B(LdaConstant), U8(30),
- B(Star), R(0),
- B(LdaConstant), U8(31),
- B(Star), R(0),
- B(LdaConstant), U8(32),
- B(Star), R(0),
- B(LdaConstant), U8(33),
- B(Star), R(0),
- B(LdaConstant), U8(34),
- B(Star), R(0),
- B(LdaConstant), U8(35),
- B(Star), R(0),
- B(LdaConstant), U8(36),
- B(Star), R(0),
- B(LdaConstant), U8(37),
- B(Star), R(0),
- B(LdaConstant), U8(38),
- B(Star), R(0),
- B(LdaConstant), U8(39),
- B(Star), R(0),
- B(LdaConstant), U8(40),
- B(Star), R(0),
- B(LdaConstant), U8(41),
- B(Star), R(0),
- B(LdaConstant), U8(42),
- B(Star), R(0),
- B(LdaConstant), U8(43),
- B(Star), R(0),
- B(LdaConstant), U8(44),
- B(Star), R(0),
- B(LdaConstant), U8(45),
- B(Star), R(0),
- B(LdaConstant), U8(46),
- B(Star), R(0),
- B(LdaConstant), U8(47),
- B(Star), R(0),
- B(LdaConstant), U8(48),
- B(Star), R(0),
- B(LdaConstant), U8(49),
- B(Star), R(0),
- B(LdaConstant), U8(50),
- B(Star), R(0),
- B(LdaConstant), U8(51),
- B(Star), R(0),
- B(LdaConstant), U8(52),
- B(Star), R(0),
- B(LdaConstant), U8(53),
- B(Star), R(0),
- B(LdaConstant), U8(54),
- B(Star), R(0),
- B(LdaConstant), U8(55),
- B(Star), R(0),
- B(LdaConstant), U8(56),
- B(Star), R(0),
- B(LdaConstant), U8(57),
- B(Star), R(0),
- B(LdaConstant), U8(58),
- B(Star), R(0),
- B(LdaConstant), U8(59),
- B(Star), R(0),
- B(LdaConstant), U8(60),
- B(Star), R(0),
- B(LdaConstant), U8(61),
- B(Star), R(0),
- B(LdaConstant), U8(62),
- B(Star), R(0),
- B(LdaConstant), U8(63),
- B(Star), R(0),
- B(LdaConstant), U8(64),
- B(Star), R(0),
- B(LdaConstant), U8(65),
- B(Star), R(0),
- B(LdaConstant), U8(66),
- B(Star), R(0),
- B(LdaConstant), U8(67),
- B(Star), R(0),
- B(LdaConstant), U8(68),
- B(Star), R(0),
- B(LdaConstant), U8(69),
- B(Star), R(0),
- B(LdaConstant), U8(70),
- B(Star), R(0),
- B(LdaConstant), U8(71),
- B(Star), R(0),
- B(LdaConstant), U8(72),
- B(Star), R(0),
- B(LdaConstant), U8(73),
- B(Star), R(0),
- B(LdaConstant), U8(74),
- B(Star), R(0),
- B(LdaConstant), U8(75),
- B(Star), R(0),
- B(LdaConstant), U8(76),
- B(Star), R(0),
- B(LdaConstant), U8(77),
- B(Star), R(0),
- B(LdaConstant), U8(78),
- B(Star), R(0),
- B(LdaConstant), U8(79),
- B(Star), R(0),
- B(LdaConstant), U8(80),
- B(Star), R(0),
- B(LdaConstant), U8(81),
- B(Star), R(0),
- B(LdaConstant), U8(82),
- B(Star), R(0),
- B(LdaConstant), U8(83),
- B(Star), R(0),
- B(LdaConstant), U8(84),
- B(Star), R(0),
- B(LdaConstant), U8(85),
- B(Star), R(0),
- B(LdaConstant), U8(86),
- B(Star), R(0),
- B(LdaConstant), U8(87),
- B(Star), R(0),
- B(LdaConstant), U8(88),
- B(Star), R(0),
- B(LdaConstant), U8(89),
- B(Star), R(0),
- B(LdaConstant), U8(90),
- B(Star), R(0),
- B(LdaConstant), U8(91),
- B(Star), R(0),
- B(LdaConstant), U8(92),
- B(Star), R(0),
- B(LdaConstant), U8(93),
- B(Star), R(0),
- B(LdaConstant), U8(94),
- B(Star), R(0),
- B(LdaConstant), U8(95),
- B(Star), R(0),
- B(LdaConstant), U8(96),
- B(Star), R(0),
- B(LdaConstant), U8(97),
- B(Star), R(0),
- B(LdaConstant), U8(98),
- B(Star), R(0),
- B(LdaConstant), U8(99),
- B(Star), R(0),
- B(LdaConstant), U8(100),
- B(Star), R(0),
- B(LdaConstant), U8(101),
- B(Star), R(0),
- B(LdaConstant), U8(102),
- B(Star), R(0),
- B(LdaConstant), U8(103),
- B(Star), R(0),
- B(LdaConstant), U8(104),
- B(Star), R(0),
- B(LdaConstant), U8(105),
- B(Star), R(0),
- B(LdaConstant), U8(106),
- B(Star), R(0),
- B(LdaConstant), U8(107),
- B(Star), R(0),
- B(LdaConstant), U8(108),
- B(Star), R(0),
- B(LdaConstant), U8(109),
- B(Star), R(0),
- B(LdaConstant), U8(110),
- B(Star), R(0),
- B(LdaConstant), U8(111),
- B(Star), R(0),
- B(LdaConstant), U8(112),
- B(Star), R(0),
- B(LdaConstant), U8(113),
- B(Star), R(0),
- B(LdaConstant), U8(114),
- B(Star), R(0),
- B(LdaConstant), U8(115),
- B(Star), R(0),
- B(LdaConstant), U8(116),
- B(Star), R(0),
- B(LdaConstant), U8(117),
- B(Star), R(0),
- B(LdaConstant), U8(118),
- B(Star), R(0),
- B(LdaConstant), U8(119),
- B(Star), R(0),
- B(LdaConstant), U8(120),
- B(Star), R(0),
- B(LdaConstant), U8(121),
- B(Star), R(0),
- B(LdaConstant), U8(122),
- B(Star), R(0),
- B(LdaConstant), U8(123),
- B(Star), R(0),
- B(LdaConstant), U8(124),
- B(Star), R(0),
- B(LdaConstant), U8(125),
- B(Star), R(0),
- B(LdaConstant), U8(126),
- B(Star), R(0),
- B(LdaConstant), U8(127),
- B(Star), R(0),
- B(LdaConstant), U8(128),
- B(Star), R(0),
- B(LdaConstant), U8(129),
- B(Star), R(0),
- B(LdaConstant), U8(130),
- B(Star), R(0),
- B(LdaConstant), U8(131),
- B(Star), R(0),
- B(LdaConstant), U8(132),
- B(Star), R(0),
- B(LdaConstant), U8(133),
- B(Star), R(0),
- B(LdaConstant), U8(134),
- B(Star), R(0),
- B(LdaConstant), U8(135),
- B(Star), R(0),
- B(LdaConstant), U8(136),
- B(Star), R(0),
- B(LdaConstant), U8(137),
- B(Star), R(0),
- B(LdaConstant), U8(138),
- B(Star), R(0),
- B(LdaConstant), U8(139),
- B(Star), R(0),
- B(LdaConstant), U8(140),
- B(Star), R(0),
- B(LdaConstant), U8(141),
- B(Star), R(0),
- B(LdaConstant), U8(142),
- B(Star), R(0),
- B(LdaConstant), U8(143),
- B(Star), R(0),
- B(LdaConstant), U8(144),
- B(Star), R(0),
- B(LdaConstant), U8(145),
- B(Star), R(0),
- B(LdaConstant), U8(146),
- B(Star), R(0),
- B(LdaConstant), U8(147),
- B(Star), R(0),
- B(LdaConstant), U8(148),
- B(Star), R(0),
- B(LdaConstant), U8(149),
- B(Star), R(0),
- B(LdaConstant), U8(150),
- B(Star), R(0),
- B(LdaConstant), U8(151),
- B(Star), R(0),
- B(LdaConstant), U8(152),
- B(Star), R(0),
- B(LdaConstant), U8(153),
- B(Star), R(0),
- B(LdaConstant), U8(154),
- B(Star), R(0),
- B(LdaConstant), U8(155),
- B(Star), R(0),
- B(LdaConstant), U8(156),
- B(Star), R(0),
- B(LdaConstant), U8(157),
- B(Star), R(0),
- B(LdaConstant), U8(158),
- B(Star), R(0),
- B(LdaConstant), U8(159),
- B(Star), R(0),
- B(LdaConstant), U8(160),
- B(Star), R(0),
- B(LdaConstant), U8(161),
- B(Star), R(0),
- B(LdaConstant), U8(162),
- B(Star), R(0),
- B(LdaConstant), U8(163),
- B(Star), R(0),
- B(LdaConstant), U8(164),
- B(Star), R(0),
- B(LdaConstant), U8(165),
- B(Star), R(0),
- B(LdaConstant), U8(166),
- B(Star), R(0),
- B(LdaConstant), U8(167),
- B(Star), R(0),
- B(LdaConstant), U8(168),
- B(Star), R(0),
- B(LdaConstant), U8(169),
- B(Star), R(0),
- B(LdaConstant), U8(170),
- B(Star), R(0),
- B(LdaConstant), U8(171),
- B(Star), R(0),
- B(LdaConstant), U8(172),
- B(Star), R(0),
- B(LdaConstant), U8(173),
- B(Star), R(0),
- B(LdaConstant), U8(174),
- B(Star), R(0),
- B(LdaConstant), U8(175),
- B(Star), R(0),
- B(LdaConstant), U8(176),
- B(Star), R(0),
- B(LdaConstant), U8(177),
- B(Star), R(0),
- B(LdaConstant), U8(178),
- B(Star), R(0),
- B(LdaConstant), U8(179),
- B(Star), R(0),
- B(LdaConstant), U8(180),
- B(Star), R(0),
- B(LdaConstant), U8(181),
- B(Star), R(0),
- B(LdaConstant), U8(182),
- B(Star), R(0),
- B(LdaConstant), U8(183),
- B(Star), R(0),
- B(LdaConstant), U8(184),
- B(Star), R(0),
- B(LdaConstant), U8(185),
- B(Star), R(0),
- B(LdaConstant), U8(186),
- B(Star), R(0),
- B(LdaConstant), U8(187),
- B(Star), R(0),
- B(LdaConstant), U8(188),
- B(Star), R(0),
- B(LdaConstant), U8(189),
- B(Star), R(0),
- B(LdaConstant), U8(190),
- B(Star), R(0),
- B(LdaConstant), U8(191),
- B(Star), R(0),
- B(LdaConstant), U8(192),
- B(Star), R(0),
- B(LdaConstant), U8(193),
- B(Star), R(0),
- B(LdaConstant), U8(194),
- B(Star), R(0),
- B(LdaConstant), U8(195),
- B(Star), R(0),
- B(LdaConstant), U8(196),
- B(Star), R(0),
- B(LdaConstant), U8(197),
- B(Star), R(0),
- B(LdaConstant), U8(198),
- B(Star), R(0),
- B(LdaConstant), U8(199),
- B(Star), R(0),
- B(LdaConstant), U8(200),
- B(Star), R(0),
- B(LdaConstant), U8(201),
- B(Star), R(0),
- B(LdaConstant), U8(202),
- B(Star), R(0),
- B(LdaConstant), U8(203),
- B(Star), R(0),
- B(LdaConstant), U8(204),
- B(Star), R(0),
- B(LdaConstant), U8(205),
- B(Star), R(0),
- B(LdaConstant), U8(206),
- B(Star), R(0),
- B(LdaConstant), U8(207),
- B(Star), R(0),
- B(LdaConstant), U8(208),
- B(Star), R(0),
- B(LdaConstant), U8(209),
- B(Star), R(0),
- B(LdaConstant), U8(210),
- B(Star), R(0),
- B(LdaConstant), U8(211),
- B(Star), R(0),
- B(LdaConstant), U8(212),
- B(Star), R(0),
- B(LdaConstant), U8(213),
- B(Star), R(0),
- B(LdaConstant), U8(214),
- B(Star), R(0),
- B(LdaConstant), U8(215),
- B(Star), R(0),
- B(LdaConstant), U8(216),
- B(Star), R(0),
- B(LdaConstant), U8(217),
- B(Star), R(0),
- B(LdaConstant), U8(218),
- B(Star), R(0),
- B(LdaConstant), U8(219),
- B(Star), R(0),
- B(LdaConstant), U8(220),
- B(Star), R(0),
- B(LdaConstant), U8(221),
- B(Star), R(0),
- B(LdaConstant), U8(222),
- B(Star), R(0),
- B(LdaConstant), U8(223),
- B(Star), R(0),
- B(LdaConstant), U8(224),
- B(Star), R(0),
- B(LdaConstant), U8(225),
- B(Star), R(0),
- B(LdaConstant), U8(226),
- B(Star), R(0),
- B(LdaConstant), U8(227),
- B(Star), R(0),
- B(LdaConstant), U8(228),
- B(Star), R(0),
- B(LdaConstant), U8(229),
- B(Star), R(0),
- B(LdaConstant), U8(230),
- B(Star), R(0),
- B(LdaConstant), U8(231),
- B(Star), R(0),
- B(LdaConstant), U8(232),
- B(Star), R(0),
- B(LdaConstant), U8(233),
- B(Star), R(0),
- B(LdaConstant), U8(234),
- B(Star), R(0),
- B(LdaConstant), U8(235),
- B(Star), R(0),
- B(LdaConstant), U8(236),
- B(Star), R(0),
- B(LdaConstant), U8(237),
- B(Star), R(0),
- B(LdaConstant), U8(238),
- B(Star), R(0),
- B(LdaConstant), U8(239),
- B(Star), R(0),
- B(LdaConstant), U8(240),
- B(Star), R(0),
- B(LdaConstant), U8(241),
- B(Star), R(0),
- B(LdaConstant), U8(242),
- B(Star), R(0),
- B(LdaConstant), U8(243),
- B(Star), R(0),
- B(LdaConstant), U8(244),
- B(Star), R(0),
- B(LdaConstant), U8(245),
- B(Star), R(0),
- B(LdaConstant), U8(246),
- B(Star), R(0),
- B(LdaConstant), U8(247),
- B(Star), R(0),
- B(LdaConstant), U8(248),
- B(Star), R(0),
- B(LdaConstant), U8(249),
- B(Star), R(0),
- B(LdaConstant), U8(250),
- B(Star), R(0),
- B(LdaConstant), U8(251),
- B(Star), R(0),
- B(LdaConstant), U8(252),
- B(Star), R(0),
- B(LdaConstant), U8(253),
- B(Star), R(0),
- B(LdaConstant), U8(254),
- B(Star), R(0),
- B(LdaConstant), U8(255),
- B(Star), R(0),
- B(LdaSmi), U8(10),
- B(Wide), B(StaLookupSlotStrict), U16(256),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 35 S> */ B(LdaConstant), U8(0),
+ /* 35 E> */ B(Star), R(0),
+ /* 47 S> */ B(LdaConstant), U8(1),
+ /* 47 E> */ B(Star), R(0),
+ /* 59 S> */ B(LdaConstant), U8(2),
+ /* 59 E> */ B(Star), R(0),
+ /* 71 S> */ B(LdaConstant), U8(3),
+ /* 71 E> */ B(Star), R(0),
+ /* 83 S> */ B(LdaConstant), U8(4),
+ /* 83 E> */ B(Star), R(0),
+ /* 95 S> */ B(LdaConstant), U8(5),
+ /* 95 E> */ B(Star), R(0),
+ /* 107 S> */ B(LdaConstant), U8(6),
+ /* 107 E> */ B(Star), R(0),
+ /* 119 S> */ B(LdaConstant), U8(7),
+ /* 119 E> */ B(Star), R(0),
+ /* 131 S> */ B(LdaConstant), U8(8),
+ /* 131 E> */ B(Star), R(0),
+ /* 143 S> */ B(LdaConstant), U8(9),
+ /* 143 E> */ B(Star), R(0),
+ /* 155 S> */ B(LdaConstant), U8(10),
+ /* 155 E> */ B(Star), R(0),
+ /* 167 S> */ B(LdaConstant), U8(11),
+ /* 167 E> */ B(Star), R(0),
+ /* 179 S> */ B(LdaConstant), U8(12),
+ /* 179 E> */ B(Star), R(0),
+ /* 191 S> */ B(LdaConstant), U8(13),
+ /* 191 E> */ B(Star), R(0),
+ /* 203 S> */ B(LdaConstant), U8(14),
+ /* 203 E> */ B(Star), R(0),
+ /* 215 S> */ B(LdaConstant), U8(15),
+ /* 215 E> */ B(Star), R(0),
+ /* 227 S> */ B(LdaConstant), U8(16),
+ /* 227 E> */ B(Star), R(0),
+ /* 239 S> */ B(LdaConstant), U8(17),
+ /* 239 E> */ B(Star), R(0),
+ /* 251 S> */ B(LdaConstant), U8(18),
+ /* 251 E> */ B(Star), R(0),
+ /* 263 S> */ B(LdaConstant), U8(19),
+ /* 263 E> */ B(Star), R(0),
+ /* 275 S> */ B(LdaConstant), U8(20),
+ /* 275 E> */ B(Star), R(0),
+ /* 287 S> */ B(LdaConstant), U8(21),
+ /* 287 E> */ B(Star), R(0),
+ /* 299 S> */ B(LdaConstant), U8(22),
+ /* 299 E> */ B(Star), R(0),
+ /* 311 S> */ B(LdaConstant), U8(23),
+ /* 311 E> */ B(Star), R(0),
+ /* 323 S> */ B(LdaConstant), U8(24),
+ /* 323 E> */ B(Star), R(0),
+ /* 335 S> */ B(LdaConstant), U8(25),
+ /* 335 E> */ B(Star), R(0),
+ /* 347 S> */ B(LdaConstant), U8(26),
+ /* 347 E> */ B(Star), R(0),
+ /* 359 S> */ B(LdaConstant), U8(27),
+ /* 359 E> */ B(Star), R(0),
+ /* 371 S> */ B(LdaConstant), U8(28),
+ /* 371 E> */ B(Star), R(0),
+ /* 383 S> */ B(LdaConstant), U8(29),
+ /* 383 E> */ B(Star), R(0),
+ /* 395 S> */ B(LdaConstant), U8(30),
+ /* 395 E> */ B(Star), R(0),
+ /* 407 S> */ B(LdaConstant), U8(31),
+ /* 407 E> */ B(Star), R(0),
+ /* 419 S> */ B(LdaConstant), U8(32),
+ /* 419 E> */ B(Star), R(0),
+ /* 431 S> */ B(LdaConstant), U8(33),
+ /* 431 E> */ B(Star), R(0),
+ /* 443 S> */ B(LdaConstant), U8(34),
+ /* 443 E> */ B(Star), R(0),
+ /* 455 S> */ B(LdaConstant), U8(35),
+ /* 455 E> */ B(Star), R(0),
+ /* 467 S> */ B(LdaConstant), U8(36),
+ /* 467 E> */ B(Star), R(0),
+ /* 479 S> */ B(LdaConstant), U8(37),
+ /* 479 E> */ B(Star), R(0),
+ /* 491 S> */ B(LdaConstant), U8(38),
+ /* 491 E> */ B(Star), R(0),
+ /* 503 S> */ B(LdaConstant), U8(39),
+ /* 503 E> */ B(Star), R(0),
+ /* 515 S> */ B(LdaConstant), U8(40),
+ /* 515 E> */ B(Star), R(0),
+ /* 527 S> */ B(LdaConstant), U8(41),
+ /* 527 E> */ B(Star), R(0),
+ /* 539 S> */ B(LdaConstant), U8(42),
+ /* 539 E> */ B(Star), R(0),
+ /* 551 S> */ B(LdaConstant), U8(43),
+ /* 551 E> */ B(Star), R(0),
+ /* 563 S> */ B(LdaConstant), U8(44),
+ /* 563 E> */ B(Star), R(0),
+ /* 575 S> */ B(LdaConstant), U8(45),
+ /* 575 E> */ B(Star), R(0),
+ /* 587 S> */ B(LdaConstant), U8(46),
+ /* 587 E> */ B(Star), R(0),
+ /* 599 S> */ B(LdaConstant), U8(47),
+ /* 599 E> */ B(Star), R(0),
+ /* 611 S> */ B(LdaConstant), U8(48),
+ /* 611 E> */ B(Star), R(0),
+ /* 623 S> */ B(LdaConstant), U8(49),
+ /* 623 E> */ B(Star), R(0),
+ /* 635 S> */ B(LdaConstant), U8(50),
+ /* 635 E> */ B(Star), R(0),
+ /* 647 S> */ B(LdaConstant), U8(51),
+ /* 647 E> */ B(Star), R(0),
+ /* 659 S> */ B(LdaConstant), U8(52),
+ /* 659 E> */ B(Star), R(0),
+ /* 671 S> */ B(LdaConstant), U8(53),
+ /* 671 E> */ B(Star), R(0),
+ /* 683 S> */ B(LdaConstant), U8(54),
+ /* 683 E> */ B(Star), R(0),
+ /* 695 S> */ B(LdaConstant), U8(55),
+ /* 695 E> */ B(Star), R(0),
+ /* 707 S> */ B(LdaConstant), U8(56),
+ /* 707 E> */ B(Star), R(0),
+ /* 719 S> */ B(LdaConstant), U8(57),
+ /* 719 E> */ B(Star), R(0),
+ /* 731 S> */ B(LdaConstant), U8(58),
+ /* 731 E> */ B(Star), R(0),
+ /* 743 S> */ B(LdaConstant), U8(59),
+ /* 743 E> */ B(Star), R(0),
+ /* 755 S> */ B(LdaConstant), U8(60),
+ /* 755 E> */ B(Star), R(0),
+ /* 767 S> */ B(LdaConstant), U8(61),
+ /* 767 E> */ B(Star), R(0),
+ /* 779 S> */ B(LdaConstant), U8(62),
+ /* 779 E> */ B(Star), R(0),
+ /* 791 S> */ B(LdaConstant), U8(63),
+ /* 791 E> */ B(Star), R(0),
+ /* 803 S> */ B(LdaConstant), U8(64),
+ /* 803 E> */ B(Star), R(0),
+ /* 815 S> */ B(LdaConstant), U8(65),
+ /* 815 E> */ B(Star), R(0),
+ /* 827 S> */ B(LdaConstant), U8(66),
+ /* 827 E> */ B(Star), R(0),
+ /* 839 S> */ B(LdaConstant), U8(67),
+ /* 839 E> */ B(Star), R(0),
+ /* 851 S> */ B(LdaConstant), U8(68),
+ /* 851 E> */ B(Star), R(0),
+ /* 863 S> */ B(LdaConstant), U8(69),
+ /* 863 E> */ B(Star), R(0),
+ /* 875 S> */ B(LdaConstant), U8(70),
+ /* 875 E> */ B(Star), R(0),
+ /* 887 S> */ B(LdaConstant), U8(71),
+ /* 887 E> */ B(Star), R(0),
+ /* 899 S> */ B(LdaConstant), U8(72),
+ /* 899 E> */ B(Star), R(0),
+ /* 911 S> */ B(LdaConstant), U8(73),
+ /* 911 E> */ B(Star), R(0),
+ /* 923 S> */ B(LdaConstant), U8(74),
+ /* 923 E> */ B(Star), R(0),
+ /* 935 S> */ B(LdaConstant), U8(75),
+ /* 935 E> */ B(Star), R(0),
+ /* 947 S> */ B(LdaConstant), U8(76),
+ /* 947 E> */ B(Star), R(0),
+ /* 959 S> */ B(LdaConstant), U8(77),
+ /* 959 E> */ B(Star), R(0),
+ /* 971 S> */ B(LdaConstant), U8(78),
+ /* 971 E> */ B(Star), R(0),
+ /* 983 S> */ B(LdaConstant), U8(79),
+ /* 983 E> */ B(Star), R(0),
+ /* 995 S> */ B(LdaConstant), U8(80),
+ /* 995 E> */ B(Star), R(0),
+ /* 1007 S> */ B(LdaConstant), U8(81),
+ /* 1007 E> */ B(Star), R(0),
+ /* 1019 S> */ B(LdaConstant), U8(82),
+ /* 1019 E> */ B(Star), R(0),
+ /* 1031 S> */ B(LdaConstant), U8(83),
+ /* 1031 E> */ B(Star), R(0),
+ /* 1043 S> */ B(LdaConstant), U8(84),
+ /* 1043 E> */ B(Star), R(0),
+ /* 1055 S> */ B(LdaConstant), U8(85),
+ /* 1055 E> */ B(Star), R(0),
+ /* 1067 S> */ B(LdaConstant), U8(86),
+ /* 1067 E> */ B(Star), R(0),
+ /* 1079 S> */ B(LdaConstant), U8(87),
+ /* 1079 E> */ B(Star), R(0),
+ /* 1091 S> */ B(LdaConstant), U8(88),
+ /* 1091 E> */ B(Star), R(0),
+ /* 1103 S> */ B(LdaConstant), U8(89),
+ /* 1103 E> */ B(Star), R(0),
+ /* 1115 S> */ B(LdaConstant), U8(90),
+ /* 1115 E> */ B(Star), R(0),
+ /* 1127 S> */ B(LdaConstant), U8(91),
+ /* 1127 E> */ B(Star), R(0),
+ /* 1139 S> */ B(LdaConstant), U8(92),
+ /* 1139 E> */ B(Star), R(0),
+ /* 1151 S> */ B(LdaConstant), U8(93),
+ /* 1151 E> */ B(Star), R(0),
+ /* 1163 S> */ B(LdaConstant), U8(94),
+ /* 1163 E> */ B(Star), R(0),
+ /* 1175 S> */ B(LdaConstant), U8(95),
+ /* 1175 E> */ B(Star), R(0),
+ /* 1187 S> */ B(LdaConstant), U8(96),
+ /* 1187 E> */ B(Star), R(0),
+ /* 1199 S> */ B(LdaConstant), U8(97),
+ /* 1199 E> */ B(Star), R(0),
+ /* 1211 S> */ B(LdaConstant), U8(98),
+ /* 1211 E> */ B(Star), R(0),
+ /* 1223 S> */ B(LdaConstant), U8(99),
+ /* 1223 E> */ B(Star), R(0),
+ /* 1235 S> */ B(LdaConstant), U8(100),
+ /* 1235 E> */ B(Star), R(0),
+ /* 1247 S> */ B(LdaConstant), U8(101),
+ /* 1247 E> */ B(Star), R(0),
+ /* 1259 S> */ B(LdaConstant), U8(102),
+ /* 1259 E> */ B(Star), R(0),
+ /* 1271 S> */ B(LdaConstant), U8(103),
+ /* 1271 E> */ B(Star), R(0),
+ /* 1283 S> */ B(LdaConstant), U8(104),
+ /* 1283 E> */ B(Star), R(0),
+ /* 1295 S> */ B(LdaConstant), U8(105),
+ /* 1295 E> */ B(Star), R(0),
+ /* 1307 S> */ B(LdaConstant), U8(106),
+ /* 1307 E> */ B(Star), R(0),
+ /* 1319 S> */ B(LdaConstant), U8(107),
+ /* 1319 E> */ B(Star), R(0),
+ /* 1331 S> */ B(LdaConstant), U8(108),
+ /* 1331 E> */ B(Star), R(0),
+ /* 1343 S> */ B(LdaConstant), U8(109),
+ /* 1343 E> */ B(Star), R(0),
+ /* 1355 S> */ B(LdaConstant), U8(110),
+ /* 1355 E> */ B(Star), R(0),
+ /* 1367 S> */ B(LdaConstant), U8(111),
+ /* 1367 E> */ B(Star), R(0),
+ /* 1379 S> */ B(LdaConstant), U8(112),
+ /* 1379 E> */ B(Star), R(0),
+ /* 1391 S> */ B(LdaConstant), U8(113),
+ /* 1391 E> */ B(Star), R(0),
+ /* 1403 S> */ B(LdaConstant), U8(114),
+ /* 1403 E> */ B(Star), R(0),
+ /* 1415 S> */ B(LdaConstant), U8(115),
+ /* 1415 E> */ B(Star), R(0),
+ /* 1427 S> */ B(LdaConstant), U8(116),
+ /* 1427 E> */ B(Star), R(0),
+ /* 1439 S> */ B(LdaConstant), U8(117),
+ /* 1439 E> */ B(Star), R(0),
+ /* 1451 S> */ B(LdaConstant), U8(118),
+ /* 1451 E> */ B(Star), R(0),
+ /* 1463 S> */ B(LdaConstant), U8(119),
+ /* 1463 E> */ B(Star), R(0),
+ /* 1475 S> */ B(LdaConstant), U8(120),
+ /* 1475 E> */ B(Star), R(0),
+ /* 1487 S> */ B(LdaConstant), U8(121),
+ /* 1487 E> */ B(Star), R(0),
+ /* 1499 S> */ B(LdaConstant), U8(122),
+ /* 1499 E> */ B(Star), R(0),
+ /* 1511 S> */ B(LdaConstant), U8(123),
+ /* 1511 E> */ B(Star), R(0),
+ /* 1523 S> */ B(LdaConstant), U8(124),
+ /* 1523 E> */ B(Star), R(0),
+ /* 1535 S> */ B(LdaConstant), U8(125),
+ /* 1535 E> */ B(Star), R(0),
+ /* 1547 S> */ B(LdaConstant), U8(126),
+ /* 1547 E> */ B(Star), R(0),
+ /* 1559 S> */ B(LdaConstant), U8(127),
+ /* 1559 E> */ B(Star), R(0),
+ /* 1571 S> */ B(LdaConstant), U8(128),
+ /* 1571 E> */ B(Star), R(0),
+ /* 1583 S> */ B(LdaConstant), U8(129),
+ /* 1583 E> */ B(Star), R(0),
+ /* 1595 S> */ B(LdaConstant), U8(130),
+ /* 1595 E> */ B(Star), R(0),
+ /* 1607 S> */ B(LdaConstant), U8(131),
+ /* 1607 E> */ B(Star), R(0),
+ /* 1619 S> */ B(LdaConstant), U8(132),
+ /* 1619 E> */ B(Star), R(0),
+ /* 1631 S> */ B(LdaConstant), U8(133),
+ /* 1631 E> */ B(Star), R(0),
+ /* 1643 S> */ B(LdaConstant), U8(134),
+ /* 1643 E> */ B(Star), R(0),
+ /* 1655 S> */ B(LdaConstant), U8(135),
+ /* 1655 E> */ B(Star), R(0),
+ /* 1667 S> */ B(LdaConstant), U8(136),
+ /* 1667 E> */ B(Star), R(0),
+ /* 1679 S> */ B(LdaConstant), U8(137),
+ /* 1679 E> */ B(Star), R(0),
+ /* 1691 S> */ B(LdaConstant), U8(138),
+ /* 1691 E> */ B(Star), R(0),
+ /* 1703 S> */ B(LdaConstant), U8(139),
+ /* 1703 E> */ B(Star), R(0),
+ /* 1715 S> */ B(LdaConstant), U8(140),
+ /* 1715 E> */ B(Star), R(0),
+ /* 1727 S> */ B(LdaConstant), U8(141),
+ /* 1727 E> */ B(Star), R(0),
+ /* 1739 S> */ B(LdaConstant), U8(142),
+ /* 1739 E> */ B(Star), R(0),
+ /* 1751 S> */ B(LdaConstant), U8(143),
+ /* 1751 E> */ B(Star), R(0),
+ /* 1763 S> */ B(LdaConstant), U8(144),
+ /* 1763 E> */ B(Star), R(0),
+ /* 1775 S> */ B(LdaConstant), U8(145),
+ /* 1775 E> */ B(Star), R(0),
+ /* 1787 S> */ B(LdaConstant), U8(146),
+ /* 1787 E> */ B(Star), R(0),
+ /* 1799 S> */ B(LdaConstant), U8(147),
+ /* 1799 E> */ B(Star), R(0),
+ /* 1811 S> */ B(LdaConstant), U8(148),
+ /* 1811 E> */ B(Star), R(0),
+ /* 1823 S> */ B(LdaConstant), U8(149),
+ /* 1823 E> */ B(Star), R(0),
+ /* 1835 S> */ B(LdaConstant), U8(150),
+ /* 1835 E> */ B(Star), R(0),
+ /* 1847 S> */ B(LdaConstant), U8(151),
+ /* 1847 E> */ B(Star), R(0),
+ /* 1859 S> */ B(LdaConstant), U8(152),
+ /* 1859 E> */ B(Star), R(0),
+ /* 1871 S> */ B(LdaConstant), U8(153),
+ /* 1871 E> */ B(Star), R(0),
+ /* 1883 S> */ B(LdaConstant), U8(154),
+ /* 1883 E> */ B(Star), R(0),
+ /* 1895 S> */ B(LdaConstant), U8(155),
+ /* 1895 E> */ B(Star), R(0),
+ /* 1907 S> */ B(LdaConstant), U8(156),
+ /* 1907 E> */ B(Star), R(0),
+ /* 1919 S> */ B(LdaConstant), U8(157),
+ /* 1919 E> */ B(Star), R(0),
+ /* 1931 S> */ B(LdaConstant), U8(158),
+ /* 1931 E> */ B(Star), R(0),
+ /* 1943 S> */ B(LdaConstant), U8(159),
+ /* 1943 E> */ B(Star), R(0),
+ /* 1955 S> */ B(LdaConstant), U8(160),
+ /* 1955 E> */ B(Star), R(0),
+ /* 1967 S> */ B(LdaConstant), U8(161),
+ /* 1967 E> */ B(Star), R(0),
+ /* 1979 S> */ B(LdaConstant), U8(162),
+ /* 1979 E> */ B(Star), R(0),
+ /* 1991 S> */ B(LdaConstant), U8(163),
+ /* 1991 E> */ B(Star), R(0),
+ /* 2003 S> */ B(LdaConstant), U8(164),
+ /* 2003 E> */ B(Star), R(0),
+ /* 2015 S> */ B(LdaConstant), U8(165),
+ /* 2015 E> */ B(Star), R(0),
+ /* 2027 S> */ B(LdaConstant), U8(166),
+ /* 2027 E> */ B(Star), R(0),
+ /* 2039 S> */ B(LdaConstant), U8(167),
+ /* 2039 E> */ B(Star), R(0),
+ /* 2051 S> */ B(LdaConstant), U8(168),
+ /* 2051 E> */ B(Star), R(0),
+ /* 2063 S> */ B(LdaConstant), U8(169),
+ /* 2063 E> */ B(Star), R(0),
+ /* 2075 S> */ B(LdaConstant), U8(170),
+ /* 2075 E> */ B(Star), R(0),
+ /* 2087 S> */ B(LdaConstant), U8(171),
+ /* 2087 E> */ B(Star), R(0),
+ /* 2099 S> */ B(LdaConstant), U8(172),
+ /* 2099 E> */ B(Star), R(0),
+ /* 2111 S> */ B(LdaConstant), U8(173),
+ /* 2111 E> */ B(Star), R(0),
+ /* 2123 S> */ B(LdaConstant), U8(174),
+ /* 2123 E> */ B(Star), R(0),
+ /* 2135 S> */ B(LdaConstant), U8(175),
+ /* 2135 E> */ B(Star), R(0),
+ /* 2147 S> */ B(LdaConstant), U8(176),
+ /* 2147 E> */ B(Star), R(0),
+ /* 2159 S> */ B(LdaConstant), U8(177),
+ /* 2159 E> */ B(Star), R(0),
+ /* 2171 S> */ B(LdaConstant), U8(178),
+ /* 2171 E> */ B(Star), R(0),
+ /* 2183 S> */ B(LdaConstant), U8(179),
+ /* 2183 E> */ B(Star), R(0),
+ /* 2195 S> */ B(LdaConstant), U8(180),
+ /* 2195 E> */ B(Star), R(0),
+ /* 2207 S> */ B(LdaConstant), U8(181),
+ /* 2207 E> */ B(Star), R(0),
+ /* 2219 S> */ B(LdaConstant), U8(182),
+ /* 2219 E> */ B(Star), R(0),
+ /* 2231 S> */ B(LdaConstant), U8(183),
+ /* 2231 E> */ B(Star), R(0),
+ /* 2243 S> */ B(LdaConstant), U8(184),
+ /* 2243 E> */ B(Star), R(0),
+ /* 2255 S> */ B(LdaConstant), U8(185),
+ /* 2255 E> */ B(Star), R(0),
+ /* 2267 S> */ B(LdaConstant), U8(186),
+ /* 2267 E> */ B(Star), R(0),
+ /* 2279 S> */ B(LdaConstant), U8(187),
+ /* 2279 E> */ B(Star), R(0),
+ /* 2291 S> */ B(LdaConstant), U8(188),
+ /* 2291 E> */ B(Star), R(0),
+ /* 2303 S> */ B(LdaConstant), U8(189),
+ /* 2303 E> */ B(Star), R(0),
+ /* 2315 S> */ B(LdaConstant), U8(190),
+ /* 2315 E> */ B(Star), R(0),
+ /* 2327 S> */ B(LdaConstant), U8(191),
+ /* 2327 E> */ B(Star), R(0),
+ /* 2339 S> */ B(LdaConstant), U8(192),
+ /* 2339 E> */ B(Star), R(0),
+ /* 2351 S> */ B(LdaConstant), U8(193),
+ /* 2351 E> */ B(Star), R(0),
+ /* 2363 S> */ B(LdaConstant), U8(194),
+ /* 2363 E> */ B(Star), R(0),
+ /* 2375 S> */ B(LdaConstant), U8(195),
+ /* 2375 E> */ B(Star), R(0),
+ /* 2387 S> */ B(LdaConstant), U8(196),
+ /* 2387 E> */ B(Star), R(0),
+ /* 2399 S> */ B(LdaConstant), U8(197),
+ /* 2399 E> */ B(Star), R(0),
+ /* 2411 S> */ B(LdaConstant), U8(198),
+ /* 2411 E> */ B(Star), R(0),
+ /* 2423 S> */ B(LdaConstant), U8(199),
+ /* 2423 E> */ B(Star), R(0),
+ /* 2435 S> */ B(LdaConstant), U8(200),
+ /* 2435 E> */ B(Star), R(0),
+ /* 2447 S> */ B(LdaConstant), U8(201),
+ /* 2447 E> */ B(Star), R(0),
+ /* 2459 S> */ B(LdaConstant), U8(202),
+ /* 2459 E> */ B(Star), R(0),
+ /* 2471 S> */ B(LdaConstant), U8(203),
+ /* 2471 E> */ B(Star), R(0),
+ /* 2483 S> */ B(LdaConstant), U8(204),
+ /* 2483 E> */ B(Star), R(0),
+ /* 2495 S> */ B(LdaConstant), U8(205),
+ /* 2495 E> */ B(Star), R(0),
+ /* 2507 S> */ B(LdaConstant), U8(206),
+ /* 2507 E> */ B(Star), R(0),
+ /* 2519 S> */ B(LdaConstant), U8(207),
+ /* 2519 E> */ B(Star), R(0),
+ /* 2531 S> */ B(LdaConstant), U8(208),
+ /* 2531 E> */ B(Star), R(0),
+ /* 2543 S> */ B(LdaConstant), U8(209),
+ /* 2543 E> */ B(Star), R(0),
+ /* 2555 S> */ B(LdaConstant), U8(210),
+ /* 2555 E> */ B(Star), R(0),
+ /* 2567 S> */ B(LdaConstant), U8(211),
+ /* 2567 E> */ B(Star), R(0),
+ /* 2579 S> */ B(LdaConstant), U8(212),
+ /* 2579 E> */ B(Star), R(0),
+ /* 2591 S> */ B(LdaConstant), U8(213),
+ /* 2591 E> */ B(Star), R(0),
+ /* 2603 S> */ B(LdaConstant), U8(214),
+ /* 2603 E> */ B(Star), R(0),
+ /* 2615 S> */ B(LdaConstant), U8(215),
+ /* 2615 E> */ B(Star), R(0),
+ /* 2627 S> */ B(LdaConstant), U8(216),
+ /* 2627 E> */ B(Star), R(0),
+ /* 2639 S> */ B(LdaConstant), U8(217),
+ /* 2639 E> */ B(Star), R(0),
+ /* 2651 S> */ B(LdaConstant), U8(218),
+ /* 2651 E> */ B(Star), R(0),
+ /* 2663 S> */ B(LdaConstant), U8(219),
+ /* 2663 E> */ B(Star), R(0),
+ /* 2675 S> */ B(LdaConstant), U8(220),
+ /* 2675 E> */ B(Star), R(0),
+ /* 2687 S> */ B(LdaConstant), U8(221),
+ /* 2687 E> */ B(Star), R(0),
+ /* 2699 S> */ B(LdaConstant), U8(222),
+ /* 2699 E> */ B(Star), R(0),
+ /* 2711 S> */ B(LdaConstant), U8(223),
+ /* 2711 E> */ B(Star), R(0),
+ /* 2723 S> */ B(LdaConstant), U8(224),
+ /* 2723 E> */ B(Star), R(0),
+ /* 2735 S> */ B(LdaConstant), U8(225),
+ /* 2735 E> */ B(Star), R(0),
+ /* 2747 S> */ B(LdaConstant), U8(226),
+ /* 2747 E> */ B(Star), R(0),
+ /* 2759 S> */ B(LdaConstant), U8(227),
+ /* 2759 E> */ B(Star), R(0),
+ /* 2771 S> */ B(LdaConstant), U8(228),
+ /* 2771 E> */ B(Star), R(0),
+ /* 2783 S> */ B(LdaConstant), U8(229),
+ /* 2783 E> */ B(Star), R(0),
+ /* 2795 S> */ B(LdaConstant), U8(230),
+ /* 2795 E> */ B(Star), R(0),
+ /* 2807 S> */ B(LdaConstant), U8(231),
+ /* 2807 E> */ B(Star), R(0),
+ /* 2819 S> */ B(LdaConstant), U8(232),
+ /* 2819 E> */ B(Star), R(0),
+ /* 2831 S> */ B(LdaConstant), U8(233),
+ /* 2831 E> */ B(Star), R(0),
+ /* 2843 S> */ B(LdaConstant), U8(234),
+ /* 2843 E> */ B(Star), R(0),
+ /* 2855 S> */ B(LdaConstant), U8(235),
+ /* 2855 E> */ B(Star), R(0),
+ /* 2867 S> */ B(LdaConstant), U8(236),
+ /* 2867 E> */ B(Star), R(0),
+ /* 2879 S> */ B(LdaConstant), U8(237),
+ /* 2879 E> */ B(Star), R(0),
+ /* 2891 S> */ B(LdaConstant), U8(238),
+ /* 2891 E> */ B(Star), R(0),
+ /* 2903 S> */ B(LdaConstant), U8(239),
+ /* 2903 E> */ B(Star), R(0),
+ /* 2915 S> */ B(LdaConstant), U8(240),
+ /* 2915 E> */ B(Star), R(0),
+ /* 2927 S> */ B(LdaConstant), U8(241),
+ /* 2927 E> */ B(Star), R(0),
+ /* 2939 S> */ B(LdaConstant), U8(242),
+ /* 2939 E> */ B(Star), R(0),
+ /* 2951 S> */ B(LdaConstant), U8(243),
+ /* 2951 E> */ B(Star), R(0),
+ /* 2963 S> */ B(LdaConstant), U8(244),
+ /* 2963 E> */ B(Star), R(0),
+ /* 2975 S> */ B(LdaConstant), U8(245),
+ /* 2975 E> */ B(Star), R(0),
+ /* 2987 S> */ B(LdaConstant), U8(246),
+ /* 2987 E> */ B(Star), R(0),
+ /* 2999 S> */ B(LdaConstant), U8(247),
+ /* 2999 E> */ B(Star), R(0),
+ /* 3011 S> */ B(LdaConstant), U8(248),
+ /* 3011 E> */ B(Star), R(0),
+ /* 3023 S> */ B(LdaConstant), U8(249),
+ /* 3023 E> */ B(Star), R(0),
+ /* 3035 S> */ B(LdaConstant), U8(250),
+ /* 3035 E> */ B(Star), R(0),
+ /* 3047 S> */ B(LdaConstant), U8(251),
+ /* 3047 E> */ B(Star), R(0),
+ /* 3059 S> */ B(LdaConstant), U8(252),
+ /* 3059 E> */ B(Star), R(0),
+ /* 3071 S> */ B(LdaConstant), U8(253),
+ /* 3071 E> */ B(Star), R(0),
+ /* 3083 S> */ B(LdaConstant), U8(254),
+ /* 3083 E> */ B(Star), R(0),
+ /* 3095 S> */ B(LdaConstant), U8(255),
+ /* 3095 E> */ B(Star), R(0),
+ /* 3099 S> */ B(LdaSmi), U8(10),
+ /* 3101 E> */ B(Wide), B(StaLookupSlotStrict), U16(256),
+ B(LdaUndefined),
+ /* 3106 S> */ B(Return),
]
constant pool: [
InstanceType::HEAP_NUMBER_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/NewTarget.golden b/test/cctest/interpreter/bytecode_expectations/NewTarget.golden
index da2d35e..08d2a13 100644
--- a/test/cctest/interpreter/bytecode_expectations/NewTarget.golden
+++ b/test/cctest/interpreter/bytecode_expectations/NewTarget.golden
@@ -15,15 +15,15 @@
parameter count: 1
bytecode array length: 19
bytecodes: [
- B(Ldar), R(new_target),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(1),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(1), U8(1),
- B(Return),
+ B(Ldar), R(new_target),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(1), U8(1),
+ /* 53 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -39,16 +39,16 @@
parameter count: 1
bytecode array length: 20
bytecodes: [
- B(Ldar), R(new_target),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(11),
- B(LdaConstant), U8(0),
- B(Star), R(1),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(1), U8(1),
- B(LdaUndefined),
- B(Return),
+ B(Ldar), R(new_target),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(Ldar), R(0),
+ B(JumpIfNotHole), U8(11),
+ B(LdaConstant), U8(0),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(1), U8(1),
+ B(LdaUndefined),
+ /* 46 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/ObjectLiterals.golden b/test/cctest/interpreter/bytecode_expectations/ObjectLiterals.golden
index 063ebbf..831218d 100644
--- a/test/cctest/interpreter/bytecode_expectations/ObjectLiterals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ObjectLiterals.golden
@@ -15,10 +15,10 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(7),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(35),
+ B(Star), R(0),
+ /* 46 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -34,10 +34,10 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(0),
+ /* 71 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -53,15 +53,15 @@
parameter count: 1
bytecode array length: 20
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Ldar), R(0),
- B(StoreICSloppy), R(1), U8(1), U8(1),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 75 E> */ B(Ldar), R(0),
+ B(StoreICSloppy), R(1), U8(1), U8(1),
+ B(Ldar), R(1),
+ /* 80 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -78,18 +78,18 @@
parameter count: 1
bytecode array length: 26
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(Add), R(2),
- B(StoreICSloppy), R(1), U8(1), U8(1),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ /* 59 E> */ B(Ldar), R(0),
+ /* 67 E> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(Add), R(2),
+ B(StoreICSloppy), R(1), U8(1), U8(1),
+ B(Ldar), R(1),
+ /* 76 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -106,13 +106,13 @@
parameter count: 1
bytecode array length: 17
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(0),
- B(CreateClosure), U8(1), U8(0),
- B(StoreICSloppy), R(0), U8(2), U8(1),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(0),
+ B(CreateClosure), U8(1), U8(0),
+ B(StoreICSloppy), R(0), U8(2), U8(1),
+ B(Ldar), R(0),
+ /* 67 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -130,13 +130,13 @@
parameter count: 1
bytecode array length: 17
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(0),
- B(CreateClosure), U8(1), U8(0),
- B(StoreICSloppy), R(0), U8(2), U8(1),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(0),
+ B(CreateClosure), U8(1), U8(0),
+ B(StoreICSloppy), R(0), U8(2), U8(1),
+ B(Ldar), R(0),
+ /* 68 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -154,21 +154,21 @@
parameter count: 1
bytecode array length: 33
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(0),
- B(Mov), R(0), R(1),
- B(LdaConstant), U8(1),
- B(Star), R(2),
- B(CreateClosure), U8(2), U8(0),
- B(Star), R(3),
- B(LdaNull),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), R(1), U8(5),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(0),
+ B(Mov), R(0), R(1),
+ B(LdaConstant), U8(1),
+ B(Star), R(2),
+ B(CreateClosure), U8(2), U8(0),
+ B(Star), R(3),
+ B(LdaNull),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), R(1), U8(5),
+ B(Ldar), R(0),
+ /* 68 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -186,21 +186,21 @@
parameter count: 1
bytecode array length: 35
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(0),
- B(Mov), R(0), R(1),
- B(LdaConstant), U8(1),
- B(Star), R(2),
- B(CreateClosure), U8(2), U8(0),
- B(Star), R(3),
- B(CreateClosure), U8(3), U8(0),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), R(1), U8(5),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(0),
+ B(Mov), R(0), R(1),
+ B(LdaConstant), U8(1),
+ B(Star), R(2),
+ B(CreateClosure), U8(2), U8(0),
+ B(Star), R(3),
+ B(CreateClosure), U8(3), U8(0),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), R(1), U8(5),
+ B(Ldar), R(0),
+ /* 102 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -219,21 +219,21 @@
parameter count: 1
bytecode array length: 33
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(0),
- B(Mov), R(0), R(1),
- B(LdaConstant), U8(1),
- B(Star), R(2),
- B(LdaNull),
- B(Star), R(3),
- B(CreateClosure), U8(2), U8(0),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), R(1), U8(5),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(0),
+ B(Mov), R(0), R(1),
+ B(LdaConstant), U8(1),
+ B(Star), R(2),
+ B(LdaNull),
+ B(Star), R(3),
+ B(CreateClosure), U8(2), U8(0),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), R(1), U8(5),
+ B(Ldar), R(0),
+ /* 74 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -251,21 +251,21 @@
parameter count: 1
bytecode array length: 33
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(Mov), R(1), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(3),
- B(Ldar), R(0),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kSetProperty), R(2), U8(4),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ B(Mov), R(1), R(2),
+ B(LdaSmi), U8(1),
+ B(Star), R(3),
+ /* 57 E> */ B(Ldar), R(0),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kSetProperty), R(2), U8(4),
+ B(Ldar), R(1),
+ /* 62 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -281,15 +281,15 @@
parameter count: 1
bytecode array length: 21
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(7),
- B(Star), R(0),
- B(Mov), R(0), R(1),
- B(LdaNull),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kInternalSetPrototype), R(1), U8(2),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(35),
+ B(Star), R(0),
+ B(Mov), R(0), R(1),
+ B(LdaNull),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kInternalSetPrototype), R(1), U8(2),
+ B(Ldar), R(0),
+ /* 62 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
@@ -305,24 +305,24 @@
parameter count: 1
bytecode array length: 37
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(CreateObjectLiteral), U8(1), U8(0), U8(7),
- B(Star), R(1),
- B(Mov), R(1), R(2),
- B(Ldar), R(0),
- B(ToName),
- B(Star), R(3),
- B(LdaSmi), U8(1),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(5),
- B(LdaZero),
- B(Star), R(6),
- B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(0),
+ /* 50 S> */ B(CreateObjectLiteral), U8(1), U8(0), U8(35),
+ B(Star), R(1),
+ B(Mov), R(1), R(2),
+ /* 60 E> */ B(Ldar), R(0),
+ B(ToName),
+ B(Star), R(3),
+ B(LdaSmi), U8(1),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(5),
+ B(LdaZero),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
+ B(Ldar), R(1),
+ /* 69 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -339,26 +339,26 @@
parameter count: 1
bytecode array length: 43
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(CreateObjectLiteral), U8(1), U8(0), U8(5),
- B(Star), R(1),
- B(Ldar), R(0),
- B(StoreICSloppy), R(1), U8(2), U8(1),
- B(Mov), R(1), R(2),
- B(Ldar), R(0),
- B(ToName),
- B(Star), R(3),
- B(LdaSmi), U8(1),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(5),
- B(LdaZero),
- B(Star), R(6),
- B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(0),
+ /* 50 S> */ B(CreateObjectLiteral), U8(1), U8(0), U8(1),
+ B(Star), R(1),
+ /* 64 E> */ B(Ldar), R(0),
+ B(StoreICSloppy), R(1), U8(2), U8(1),
+ B(Mov), R(1), R(2),
+ /* 68 E> */ B(Ldar), R(0),
+ B(ToName),
+ B(Star), R(3),
+ B(LdaSmi), U8(1),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(5),
+ B(LdaZero),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
+ B(Ldar), R(1),
+ /* 77 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -376,29 +376,29 @@
parameter count: 1
bytecode array length: 53
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(CreateObjectLiteral), U8(1), U8(1), U8(7),
- B(Star), R(1),
- B(Mov), R(1), R(2),
- B(Ldar), R(0),
- B(ToName),
- B(Star), R(3),
- B(LdaSmi), U8(1),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(5),
- B(LdaZero),
- B(Star), R(6),
- B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
- B(Mov), R(1), R(2),
- B(CreateObjectLiteral), U8(1), U8(0), U8(7),
- B(Star), R(4),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kInternalSetPrototype), R(2), U8(2),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(0),
+ /* 50 S> */ B(CreateObjectLiteral), U8(1), U8(1), U8(35),
+ B(Star), R(1),
+ B(Mov), R(1), R(2),
+ /* 60 E> */ B(Ldar), R(0),
+ B(ToName),
+ B(Star), R(3),
+ B(LdaSmi), U8(1),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(5),
+ B(LdaZero),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
+ B(Mov), R(1), R(2),
+ B(CreateObjectLiteral), U8(1), U8(0), U8(35),
+ B(Star), R(4),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kInternalSetPrototype), R(2), U8(2),
+ B(Ldar), R(1),
+ /* 84 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
@@ -415,40 +415,40 @@
parameter count: 1
bytecode array length: 77
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(CreateObjectLiteral), U8(1), U8(0), U8(7),
- B(Star), R(1),
- B(Mov), R(1), R(2),
- B(Ldar), R(0),
- B(ToName),
- B(Star), R(3),
- B(LdaConstant), U8(2),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(5),
- B(LdaZero),
- B(Star), R(6),
- B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
- B(Mov), R(1), R(2),
- B(LdaConstant), U8(3),
- B(Star), R(3),
- B(CreateClosure), U8(4), U8(0),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kDefineGetterPropertyUnchecked), R(2), U8(4),
- B(Mov), R(1), R(2),
- B(LdaConstant), U8(3),
- B(Star), R(3),
- B(CreateClosure), U8(5), U8(0),
- B(Star), R(4),
- B(LdaZero),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kDefineSetterPropertyUnchecked), R(2), U8(4),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(0),
+ /* 50 S> */ B(CreateObjectLiteral), U8(1), U8(0), U8(35),
+ B(Star), R(1),
+ B(Mov), R(1), R(2),
+ /* 60 E> */ B(Ldar), R(0),
+ B(ToName),
+ B(Star), R(3),
+ B(LdaConstant), U8(2),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(5),
+ B(LdaZero),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
+ B(Mov), R(1), R(2),
+ B(LdaConstant), U8(3),
+ B(Star), R(3),
+ B(CreateClosure), U8(4), U8(0),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kDefineGetterPropertyUnchecked), R(2), U8(4),
+ B(Mov), R(1), R(2),
+ B(LdaConstant), U8(3),
+ B(Star), R(3),
+ B(CreateClosure), U8(5), U8(0),
+ B(Star), R(4),
+ B(LdaZero),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kDefineSetterPropertyUnchecked), R(2), U8(4),
+ B(Ldar), R(1),
+ /* 99 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/ObjectLiteralsWide.golden b/test/cctest/interpreter/bytecode_expectations/ObjectLiteralsWide.golden
index 83c6fe9..9f92943 100644
--- a/test/cctest/interpreter/bytecode_expectations/ObjectLiteralsWide.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ObjectLiteralsWide.golden
@@ -272,522 +272,522 @@
parameter count: 1
bytecode array length: 1035
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(2),
- B(Star), R(0),
- B(LdaConstant), U8(3),
- B(Star), R(0),
- B(LdaConstant), U8(4),
- B(Star), R(0),
- B(LdaConstant), U8(5),
- B(Star), R(0),
- B(LdaConstant), U8(6),
- B(Star), R(0),
- B(LdaConstant), U8(7),
- B(Star), R(0),
- B(LdaConstant), U8(8),
- B(Star), R(0),
- B(LdaConstant), U8(9),
- B(Star), R(0),
- B(LdaConstant), U8(10),
- B(Star), R(0),
- B(LdaConstant), U8(11),
- B(Star), R(0),
- B(LdaConstant), U8(12),
- B(Star), R(0),
- B(LdaConstant), U8(13),
- B(Star), R(0),
- B(LdaConstant), U8(14),
- B(Star), R(0),
- B(LdaConstant), U8(15),
- B(Star), R(0),
- B(LdaConstant), U8(16),
- B(Star), R(0),
- B(LdaConstant), U8(17),
- B(Star), R(0),
- B(LdaConstant), U8(18),
- B(Star), R(0),
- B(LdaConstant), U8(19),
- B(Star), R(0),
- B(LdaConstant), U8(20),
- B(Star), R(0),
- B(LdaConstant), U8(21),
- B(Star), R(0),
- B(LdaConstant), U8(22),
- B(Star), R(0),
- B(LdaConstant), U8(23),
- B(Star), R(0),
- B(LdaConstant), U8(24),
- B(Star), R(0),
- B(LdaConstant), U8(25),
- B(Star), R(0),
- B(LdaConstant), U8(26),
- B(Star), R(0),
- B(LdaConstant), U8(27),
- B(Star), R(0),
- B(LdaConstant), U8(28),
- B(Star), R(0),
- B(LdaConstant), U8(29),
- B(Star), R(0),
- B(LdaConstant), U8(30),
- B(Star), R(0),
- B(LdaConstant), U8(31),
- B(Star), R(0),
- B(LdaConstant), U8(32),
- B(Star), R(0),
- B(LdaConstant), U8(33),
- B(Star), R(0),
- B(LdaConstant), U8(34),
- B(Star), R(0),
- B(LdaConstant), U8(35),
- B(Star), R(0),
- B(LdaConstant), U8(36),
- B(Star), R(0),
- B(LdaConstant), U8(37),
- B(Star), R(0),
- B(LdaConstant), U8(38),
- B(Star), R(0),
- B(LdaConstant), U8(39),
- B(Star), R(0),
- B(LdaConstant), U8(40),
- B(Star), R(0),
- B(LdaConstant), U8(41),
- B(Star), R(0),
- B(LdaConstant), U8(42),
- B(Star), R(0),
- B(LdaConstant), U8(43),
- B(Star), R(0),
- B(LdaConstant), U8(44),
- B(Star), R(0),
- B(LdaConstant), U8(45),
- B(Star), R(0),
- B(LdaConstant), U8(46),
- B(Star), R(0),
- B(LdaConstant), U8(47),
- B(Star), R(0),
- B(LdaConstant), U8(48),
- B(Star), R(0),
- B(LdaConstant), U8(49),
- B(Star), R(0),
- B(LdaConstant), U8(50),
- B(Star), R(0),
- B(LdaConstant), U8(51),
- B(Star), R(0),
- B(LdaConstant), U8(52),
- B(Star), R(0),
- B(LdaConstant), U8(53),
- B(Star), R(0),
- B(LdaConstant), U8(54),
- B(Star), R(0),
- B(LdaConstant), U8(55),
- B(Star), R(0),
- B(LdaConstant), U8(56),
- B(Star), R(0),
- B(LdaConstant), U8(57),
- B(Star), R(0),
- B(LdaConstant), U8(58),
- B(Star), R(0),
- B(LdaConstant), U8(59),
- B(Star), R(0),
- B(LdaConstant), U8(60),
- B(Star), R(0),
- B(LdaConstant), U8(61),
- B(Star), R(0),
- B(LdaConstant), U8(62),
- B(Star), R(0),
- B(LdaConstant), U8(63),
- B(Star), R(0),
- B(LdaConstant), U8(64),
- B(Star), R(0),
- B(LdaConstant), U8(65),
- B(Star), R(0),
- B(LdaConstant), U8(66),
- B(Star), R(0),
- B(LdaConstant), U8(67),
- B(Star), R(0),
- B(LdaConstant), U8(68),
- B(Star), R(0),
- B(LdaConstant), U8(69),
- B(Star), R(0),
- B(LdaConstant), U8(70),
- B(Star), R(0),
- B(LdaConstant), U8(71),
- B(Star), R(0),
- B(LdaConstant), U8(72),
- B(Star), R(0),
- B(LdaConstant), U8(73),
- B(Star), R(0),
- B(LdaConstant), U8(74),
- B(Star), R(0),
- B(LdaConstant), U8(75),
- B(Star), R(0),
- B(LdaConstant), U8(76),
- B(Star), R(0),
- B(LdaConstant), U8(77),
- B(Star), R(0),
- B(LdaConstant), U8(78),
- B(Star), R(0),
- B(LdaConstant), U8(79),
- B(Star), R(0),
- B(LdaConstant), U8(80),
- B(Star), R(0),
- B(LdaConstant), U8(81),
- B(Star), R(0),
- B(LdaConstant), U8(82),
- B(Star), R(0),
- B(LdaConstant), U8(83),
- B(Star), R(0),
- B(LdaConstant), U8(84),
- B(Star), R(0),
- B(LdaConstant), U8(85),
- B(Star), R(0),
- B(LdaConstant), U8(86),
- B(Star), R(0),
- B(LdaConstant), U8(87),
- B(Star), R(0),
- B(LdaConstant), U8(88),
- B(Star), R(0),
- B(LdaConstant), U8(89),
- B(Star), R(0),
- B(LdaConstant), U8(90),
- B(Star), R(0),
- B(LdaConstant), U8(91),
- B(Star), R(0),
- B(LdaConstant), U8(92),
- B(Star), R(0),
- B(LdaConstant), U8(93),
- B(Star), R(0),
- B(LdaConstant), U8(94),
- B(Star), R(0),
- B(LdaConstant), U8(95),
- B(Star), R(0),
- B(LdaConstant), U8(96),
- B(Star), R(0),
- B(LdaConstant), U8(97),
- B(Star), R(0),
- B(LdaConstant), U8(98),
- B(Star), R(0),
- B(LdaConstant), U8(99),
- B(Star), R(0),
- B(LdaConstant), U8(100),
- B(Star), R(0),
- B(LdaConstant), U8(101),
- B(Star), R(0),
- B(LdaConstant), U8(102),
- B(Star), R(0),
- B(LdaConstant), U8(103),
- B(Star), R(0),
- B(LdaConstant), U8(104),
- B(Star), R(0),
- B(LdaConstant), U8(105),
- B(Star), R(0),
- B(LdaConstant), U8(106),
- B(Star), R(0),
- B(LdaConstant), U8(107),
- B(Star), R(0),
- B(LdaConstant), U8(108),
- B(Star), R(0),
- B(LdaConstant), U8(109),
- B(Star), R(0),
- B(LdaConstant), U8(110),
- B(Star), R(0),
- B(LdaConstant), U8(111),
- B(Star), R(0),
- B(LdaConstant), U8(112),
- B(Star), R(0),
- B(LdaConstant), U8(113),
- B(Star), R(0),
- B(LdaConstant), U8(114),
- B(Star), R(0),
- B(LdaConstant), U8(115),
- B(Star), R(0),
- B(LdaConstant), U8(116),
- B(Star), R(0),
- B(LdaConstant), U8(117),
- B(Star), R(0),
- B(LdaConstant), U8(118),
- B(Star), R(0),
- B(LdaConstant), U8(119),
- B(Star), R(0),
- B(LdaConstant), U8(120),
- B(Star), R(0),
- B(LdaConstant), U8(121),
- B(Star), R(0),
- B(LdaConstant), U8(122),
- B(Star), R(0),
- B(LdaConstant), U8(123),
- B(Star), R(0),
- B(LdaConstant), U8(124),
- B(Star), R(0),
- B(LdaConstant), U8(125),
- B(Star), R(0),
- B(LdaConstant), U8(126),
- B(Star), R(0),
- B(LdaConstant), U8(127),
- B(Star), R(0),
- B(LdaConstant), U8(128),
- B(Star), R(0),
- B(LdaConstant), U8(129),
- B(Star), R(0),
- B(LdaConstant), U8(130),
- B(Star), R(0),
- B(LdaConstant), U8(131),
- B(Star), R(0),
- B(LdaConstant), U8(132),
- B(Star), R(0),
- B(LdaConstant), U8(133),
- B(Star), R(0),
- B(LdaConstant), U8(134),
- B(Star), R(0),
- B(LdaConstant), U8(135),
- B(Star), R(0),
- B(LdaConstant), U8(136),
- B(Star), R(0),
- B(LdaConstant), U8(137),
- B(Star), R(0),
- B(LdaConstant), U8(138),
- B(Star), R(0),
- B(LdaConstant), U8(139),
- B(Star), R(0),
- B(LdaConstant), U8(140),
- B(Star), R(0),
- B(LdaConstant), U8(141),
- B(Star), R(0),
- B(LdaConstant), U8(142),
- B(Star), R(0),
- B(LdaConstant), U8(143),
- B(Star), R(0),
- B(LdaConstant), U8(144),
- B(Star), R(0),
- B(LdaConstant), U8(145),
- B(Star), R(0),
- B(LdaConstant), U8(146),
- B(Star), R(0),
- B(LdaConstant), U8(147),
- B(Star), R(0),
- B(LdaConstant), U8(148),
- B(Star), R(0),
- B(LdaConstant), U8(149),
- B(Star), R(0),
- B(LdaConstant), U8(150),
- B(Star), R(0),
- B(LdaConstant), U8(151),
- B(Star), R(0),
- B(LdaConstant), U8(152),
- B(Star), R(0),
- B(LdaConstant), U8(153),
- B(Star), R(0),
- B(LdaConstant), U8(154),
- B(Star), R(0),
- B(LdaConstant), U8(155),
- B(Star), R(0),
- B(LdaConstant), U8(156),
- B(Star), R(0),
- B(LdaConstant), U8(157),
- B(Star), R(0),
- B(LdaConstant), U8(158),
- B(Star), R(0),
- B(LdaConstant), U8(159),
- B(Star), R(0),
- B(LdaConstant), U8(160),
- B(Star), R(0),
- B(LdaConstant), U8(161),
- B(Star), R(0),
- B(LdaConstant), U8(162),
- B(Star), R(0),
- B(LdaConstant), U8(163),
- B(Star), R(0),
- B(LdaConstant), U8(164),
- B(Star), R(0),
- B(LdaConstant), U8(165),
- B(Star), R(0),
- B(LdaConstant), U8(166),
- B(Star), R(0),
- B(LdaConstant), U8(167),
- B(Star), R(0),
- B(LdaConstant), U8(168),
- B(Star), R(0),
- B(LdaConstant), U8(169),
- B(Star), R(0),
- B(LdaConstant), U8(170),
- B(Star), R(0),
- B(LdaConstant), U8(171),
- B(Star), R(0),
- B(LdaConstant), U8(172),
- B(Star), R(0),
- B(LdaConstant), U8(173),
- B(Star), R(0),
- B(LdaConstant), U8(174),
- B(Star), R(0),
- B(LdaConstant), U8(175),
- B(Star), R(0),
- B(LdaConstant), U8(176),
- B(Star), R(0),
- B(LdaConstant), U8(177),
- B(Star), R(0),
- B(LdaConstant), U8(178),
- B(Star), R(0),
- B(LdaConstant), U8(179),
- B(Star), R(0),
- B(LdaConstant), U8(180),
- B(Star), R(0),
- B(LdaConstant), U8(181),
- B(Star), R(0),
- B(LdaConstant), U8(182),
- B(Star), R(0),
- B(LdaConstant), U8(183),
- B(Star), R(0),
- B(LdaConstant), U8(184),
- B(Star), R(0),
- B(LdaConstant), U8(185),
- B(Star), R(0),
- B(LdaConstant), U8(186),
- B(Star), R(0),
- B(LdaConstant), U8(187),
- B(Star), R(0),
- B(LdaConstant), U8(188),
- B(Star), R(0),
- B(LdaConstant), U8(189),
- B(Star), R(0),
- B(LdaConstant), U8(190),
- B(Star), R(0),
- B(LdaConstant), U8(191),
- B(Star), R(0),
- B(LdaConstant), U8(192),
- B(Star), R(0),
- B(LdaConstant), U8(193),
- B(Star), R(0),
- B(LdaConstant), U8(194),
- B(Star), R(0),
- B(LdaConstant), U8(195),
- B(Star), R(0),
- B(LdaConstant), U8(196),
- B(Star), R(0),
- B(LdaConstant), U8(197),
- B(Star), R(0),
- B(LdaConstant), U8(198),
- B(Star), R(0),
- B(LdaConstant), U8(199),
- B(Star), R(0),
- B(LdaConstant), U8(200),
- B(Star), R(0),
- B(LdaConstant), U8(201),
- B(Star), R(0),
- B(LdaConstant), U8(202),
- B(Star), R(0),
- B(LdaConstant), U8(203),
- B(Star), R(0),
- B(LdaConstant), U8(204),
- B(Star), R(0),
- B(LdaConstant), U8(205),
- B(Star), R(0),
- B(LdaConstant), U8(206),
- B(Star), R(0),
- B(LdaConstant), U8(207),
- B(Star), R(0),
- B(LdaConstant), U8(208),
- B(Star), R(0),
- B(LdaConstant), U8(209),
- B(Star), R(0),
- B(LdaConstant), U8(210),
- B(Star), R(0),
- B(LdaConstant), U8(211),
- B(Star), R(0),
- B(LdaConstant), U8(212),
- B(Star), R(0),
- B(LdaConstant), U8(213),
- B(Star), R(0),
- B(LdaConstant), U8(214),
- B(Star), R(0),
- B(LdaConstant), U8(215),
- B(Star), R(0),
- B(LdaConstant), U8(216),
- B(Star), R(0),
- B(LdaConstant), U8(217),
- B(Star), R(0),
- B(LdaConstant), U8(218),
- B(Star), R(0),
- B(LdaConstant), U8(219),
- B(Star), R(0),
- B(LdaConstant), U8(220),
- B(Star), R(0),
- B(LdaConstant), U8(221),
- B(Star), R(0),
- B(LdaConstant), U8(222),
- B(Star), R(0),
- B(LdaConstant), U8(223),
- B(Star), R(0),
- B(LdaConstant), U8(224),
- B(Star), R(0),
- B(LdaConstant), U8(225),
- B(Star), R(0),
- B(LdaConstant), U8(226),
- B(Star), R(0),
- B(LdaConstant), U8(227),
- B(Star), R(0),
- B(LdaConstant), U8(228),
- B(Star), R(0),
- B(LdaConstant), U8(229),
- B(Star), R(0),
- B(LdaConstant), U8(230),
- B(Star), R(0),
- B(LdaConstant), U8(231),
- B(Star), R(0),
- B(LdaConstant), U8(232),
- B(Star), R(0),
- B(LdaConstant), U8(233),
- B(Star), R(0),
- B(LdaConstant), U8(234),
- B(Star), R(0),
- B(LdaConstant), U8(235),
- B(Star), R(0),
- B(LdaConstant), U8(236),
- B(Star), R(0),
- B(LdaConstant), U8(237),
- B(Star), R(0),
- B(LdaConstant), U8(238),
- B(Star), R(0),
- B(LdaConstant), U8(239),
- B(Star), R(0),
- B(LdaConstant), U8(240),
- B(Star), R(0),
- B(LdaConstant), U8(241),
- B(Star), R(0),
- B(LdaConstant), U8(242),
- B(Star), R(0),
- B(LdaConstant), U8(243),
- B(Star), R(0),
- B(LdaConstant), U8(244),
- B(Star), R(0),
- B(LdaConstant), U8(245),
- B(Star), R(0),
- B(LdaConstant), U8(246),
- B(Star), R(0),
- B(LdaConstant), U8(247),
- B(Star), R(0),
- B(LdaConstant), U8(248),
- B(Star), R(0),
- B(LdaConstant), U8(249),
- B(Star), R(0),
- B(LdaConstant), U8(250),
- B(Star), R(0),
- B(LdaConstant), U8(251),
- B(Star), R(0),
- B(LdaConstant), U8(252),
- B(Star), R(0),
- B(LdaConstant), U8(253),
- B(Star), R(0),
- B(LdaConstant), U8(254),
- B(Star), R(0),
- B(LdaConstant), U8(255),
- B(Star), R(0),
- B(Wide), B(CreateObjectLiteral), U16(256), U16(0), U8(5),
- B(Star), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 41 S> */ B(LdaConstant), U8(0),
+ /* 43 E> */ B(Star), R(0),
+ /* 51 S> */ B(LdaConstant), U8(1),
+ /* 53 E> */ B(Star), R(0),
+ /* 61 S> */ B(LdaConstant), U8(2),
+ /* 63 E> */ B(Star), R(0),
+ /* 71 S> */ B(LdaConstant), U8(3),
+ /* 73 E> */ B(Star), R(0),
+ /* 81 S> */ B(LdaConstant), U8(4),
+ /* 83 E> */ B(Star), R(0),
+ /* 91 S> */ B(LdaConstant), U8(5),
+ /* 93 E> */ B(Star), R(0),
+ /* 101 S> */ B(LdaConstant), U8(6),
+ /* 103 E> */ B(Star), R(0),
+ /* 111 S> */ B(LdaConstant), U8(7),
+ /* 113 E> */ B(Star), R(0),
+ /* 121 S> */ B(LdaConstant), U8(8),
+ /* 123 E> */ B(Star), R(0),
+ /* 131 S> */ B(LdaConstant), U8(9),
+ /* 133 E> */ B(Star), R(0),
+ /* 141 S> */ B(LdaConstant), U8(10),
+ /* 143 E> */ B(Star), R(0),
+ /* 151 S> */ B(LdaConstant), U8(11),
+ /* 153 E> */ B(Star), R(0),
+ /* 161 S> */ B(LdaConstant), U8(12),
+ /* 163 E> */ B(Star), R(0),
+ /* 171 S> */ B(LdaConstant), U8(13),
+ /* 173 E> */ B(Star), R(0),
+ /* 181 S> */ B(LdaConstant), U8(14),
+ /* 183 E> */ B(Star), R(0),
+ /* 191 S> */ B(LdaConstant), U8(15),
+ /* 193 E> */ B(Star), R(0),
+ /* 201 S> */ B(LdaConstant), U8(16),
+ /* 203 E> */ B(Star), R(0),
+ /* 211 S> */ B(LdaConstant), U8(17),
+ /* 213 E> */ B(Star), R(0),
+ /* 221 S> */ B(LdaConstant), U8(18),
+ /* 223 E> */ B(Star), R(0),
+ /* 231 S> */ B(LdaConstant), U8(19),
+ /* 233 E> */ B(Star), R(0),
+ /* 241 S> */ B(LdaConstant), U8(20),
+ /* 243 E> */ B(Star), R(0),
+ /* 251 S> */ B(LdaConstant), U8(21),
+ /* 253 E> */ B(Star), R(0),
+ /* 261 S> */ B(LdaConstant), U8(22),
+ /* 263 E> */ B(Star), R(0),
+ /* 271 S> */ B(LdaConstant), U8(23),
+ /* 273 E> */ B(Star), R(0),
+ /* 281 S> */ B(LdaConstant), U8(24),
+ /* 283 E> */ B(Star), R(0),
+ /* 291 S> */ B(LdaConstant), U8(25),
+ /* 293 E> */ B(Star), R(0),
+ /* 301 S> */ B(LdaConstant), U8(26),
+ /* 303 E> */ B(Star), R(0),
+ /* 311 S> */ B(LdaConstant), U8(27),
+ /* 313 E> */ B(Star), R(0),
+ /* 321 S> */ B(LdaConstant), U8(28),
+ /* 323 E> */ B(Star), R(0),
+ /* 331 S> */ B(LdaConstant), U8(29),
+ /* 333 E> */ B(Star), R(0),
+ /* 341 S> */ B(LdaConstant), U8(30),
+ /* 343 E> */ B(Star), R(0),
+ /* 351 S> */ B(LdaConstant), U8(31),
+ /* 353 E> */ B(Star), R(0),
+ /* 361 S> */ B(LdaConstant), U8(32),
+ /* 363 E> */ B(Star), R(0),
+ /* 371 S> */ B(LdaConstant), U8(33),
+ /* 373 E> */ B(Star), R(0),
+ /* 381 S> */ B(LdaConstant), U8(34),
+ /* 383 E> */ B(Star), R(0),
+ /* 391 S> */ B(LdaConstant), U8(35),
+ /* 393 E> */ B(Star), R(0),
+ /* 401 S> */ B(LdaConstant), U8(36),
+ /* 403 E> */ B(Star), R(0),
+ /* 411 S> */ B(LdaConstant), U8(37),
+ /* 413 E> */ B(Star), R(0),
+ /* 421 S> */ B(LdaConstant), U8(38),
+ /* 423 E> */ B(Star), R(0),
+ /* 431 S> */ B(LdaConstant), U8(39),
+ /* 433 E> */ B(Star), R(0),
+ /* 441 S> */ B(LdaConstant), U8(40),
+ /* 443 E> */ B(Star), R(0),
+ /* 451 S> */ B(LdaConstant), U8(41),
+ /* 453 E> */ B(Star), R(0),
+ /* 461 S> */ B(LdaConstant), U8(42),
+ /* 463 E> */ B(Star), R(0),
+ /* 471 S> */ B(LdaConstant), U8(43),
+ /* 473 E> */ B(Star), R(0),
+ /* 481 S> */ B(LdaConstant), U8(44),
+ /* 483 E> */ B(Star), R(0),
+ /* 491 S> */ B(LdaConstant), U8(45),
+ /* 493 E> */ B(Star), R(0),
+ /* 501 S> */ B(LdaConstant), U8(46),
+ /* 503 E> */ B(Star), R(0),
+ /* 511 S> */ B(LdaConstant), U8(47),
+ /* 513 E> */ B(Star), R(0),
+ /* 521 S> */ B(LdaConstant), U8(48),
+ /* 523 E> */ B(Star), R(0),
+ /* 531 S> */ B(LdaConstant), U8(49),
+ /* 533 E> */ B(Star), R(0),
+ /* 541 S> */ B(LdaConstant), U8(50),
+ /* 543 E> */ B(Star), R(0),
+ /* 551 S> */ B(LdaConstant), U8(51),
+ /* 553 E> */ B(Star), R(0),
+ /* 561 S> */ B(LdaConstant), U8(52),
+ /* 563 E> */ B(Star), R(0),
+ /* 571 S> */ B(LdaConstant), U8(53),
+ /* 573 E> */ B(Star), R(0),
+ /* 581 S> */ B(LdaConstant), U8(54),
+ /* 583 E> */ B(Star), R(0),
+ /* 591 S> */ B(LdaConstant), U8(55),
+ /* 593 E> */ B(Star), R(0),
+ /* 601 S> */ B(LdaConstant), U8(56),
+ /* 603 E> */ B(Star), R(0),
+ /* 611 S> */ B(LdaConstant), U8(57),
+ /* 613 E> */ B(Star), R(0),
+ /* 621 S> */ B(LdaConstant), U8(58),
+ /* 623 E> */ B(Star), R(0),
+ /* 631 S> */ B(LdaConstant), U8(59),
+ /* 633 E> */ B(Star), R(0),
+ /* 641 S> */ B(LdaConstant), U8(60),
+ /* 643 E> */ B(Star), R(0),
+ /* 651 S> */ B(LdaConstant), U8(61),
+ /* 653 E> */ B(Star), R(0),
+ /* 661 S> */ B(LdaConstant), U8(62),
+ /* 663 E> */ B(Star), R(0),
+ /* 671 S> */ B(LdaConstant), U8(63),
+ /* 673 E> */ B(Star), R(0),
+ /* 681 S> */ B(LdaConstant), U8(64),
+ /* 683 E> */ B(Star), R(0),
+ /* 691 S> */ B(LdaConstant), U8(65),
+ /* 693 E> */ B(Star), R(0),
+ /* 701 S> */ B(LdaConstant), U8(66),
+ /* 703 E> */ B(Star), R(0),
+ /* 711 S> */ B(LdaConstant), U8(67),
+ /* 713 E> */ B(Star), R(0),
+ /* 721 S> */ B(LdaConstant), U8(68),
+ /* 723 E> */ B(Star), R(0),
+ /* 731 S> */ B(LdaConstant), U8(69),
+ /* 733 E> */ B(Star), R(0),
+ /* 741 S> */ B(LdaConstant), U8(70),
+ /* 743 E> */ B(Star), R(0),
+ /* 751 S> */ B(LdaConstant), U8(71),
+ /* 753 E> */ B(Star), R(0),
+ /* 761 S> */ B(LdaConstant), U8(72),
+ /* 763 E> */ B(Star), R(0),
+ /* 771 S> */ B(LdaConstant), U8(73),
+ /* 773 E> */ B(Star), R(0),
+ /* 781 S> */ B(LdaConstant), U8(74),
+ /* 783 E> */ B(Star), R(0),
+ /* 791 S> */ B(LdaConstant), U8(75),
+ /* 793 E> */ B(Star), R(0),
+ /* 801 S> */ B(LdaConstant), U8(76),
+ /* 803 E> */ B(Star), R(0),
+ /* 811 S> */ B(LdaConstant), U8(77),
+ /* 813 E> */ B(Star), R(0),
+ /* 821 S> */ B(LdaConstant), U8(78),
+ /* 823 E> */ B(Star), R(0),
+ /* 831 S> */ B(LdaConstant), U8(79),
+ /* 833 E> */ B(Star), R(0),
+ /* 841 S> */ B(LdaConstant), U8(80),
+ /* 843 E> */ B(Star), R(0),
+ /* 851 S> */ B(LdaConstant), U8(81),
+ /* 853 E> */ B(Star), R(0),
+ /* 861 S> */ B(LdaConstant), U8(82),
+ /* 863 E> */ B(Star), R(0),
+ /* 871 S> */ B(LdaConstant), U8(83),
+ /* 873 E> */ B(Star), R(0),
+ /* 881 S> */ B(LdaConstant), U8(84),
+ /* 883 E> */ B(Star), R(0),
+ /* 891 S> */ B(LdaConstant), U8(85),
+ /* 893 E> */ B(Star), R(0),
+ /* 901 S> */ B(LdaConstant), U8(86),
+ /* 903 E> */ B(Star), R(0),
+ /* 911 S> */ B(LdaConstant), U8(87),
+ /* 913 E> */ B(Star), R(0),
+ /* 921 S> */ B(LdaConstant), U8(88),
+ /* 923 E> */ B(Star), R(0),
+ /* 931 S> */ B(LdaConstant), U8(89),
+ /* 933 E> */ B(Star), R(0),
+ /* 941 S> */ B(LdaConstant), U8(90),
+ /* 943 E> */ B(Star), R(0),
+ /* 951 S> */ B(LdaConstant), U8(91),
+ /* 953 E> */ B(Star), R(0),
+ /* 961 S> */ B(LdaConstant), U8(92),
+ /* 963 E> */ B(Star), R(0),
+ /* 971 S> */ B(LdaConstant), U8(93),
+ /* 973 E> */ B(Star), R(0),
+ /* 981 S> */ B(LdaConstant), U8(94),
+ /* 983 E> */ B(Star), R(0),
+ /* 991 S> */ B(LdaConstant), U8(95),
+ /* 993 E> */ B(Star), R(0),
+ /* 1001 S> */ B(LdaConstant), U8(96),
+ /* 1003 E> */ B(Star), R(0),
+ /* 1011 S> */ B(LdaConstant), U8(97),
+ /* 1013 E> */ B(Star), R(0),
+ /* 1021 S> */ B(LdaConstant), U8(98),
+ /* 1023 E> */ B(Star), R(0),
+ /* 1031 S> */ B(LdaConstant), U8(99),
+ /* 1033 E> */ B(Star), R(0),
+ /* 1041 S> */ B(LdaConstant), U8(100),
+ /* 1043 E> */ B(Star), R(0),
+ /* 1051 S> */ B(LdaConstant), U8(101),
+ /* 1053 E> */ B(Star), R(0),
+ /* 1061 S> */ B(LdaConstant), U8(102),
+ /* 1063 E> */ B(Star), R(0),
+ /* 1071 S> */ B(LdaConstant), U8(103),
+ /* 1073 E> */ B(Star), R(0),
+ /* 1081 S> */ B(LdaConstant), U8(104),
+ /* 1083 E> */ B(Star), R(0),
+ /* 1091 S> */ B(LdaConstant), U8(105),
+ /* 1093 E> */ B(Star), R(0),
+ /* 1101 S> */ B(LdaConstant), U8(106),
+ /* 1103 E> */ B(Star), R(0),
+ /* 1111 S> */ B(LdaConstant), U8(107),
+ /* 1113 E> */ B(Star), R(0),
+ /* 1121 S> */ B(LdaConstant), U8(108),
+ /* 1123 E> */ B(Star), R(0),
+ /* 1131 S> */ B(LdaConstant), U8(109),
+ /* 1133 E> */ B(Star), R(0),
+ /* 1141 S> */ B(LdaConstant), U8(110),
+ /* 1143 E> */ B(Star), R(0),
+ /* 1151 S> */ B(LdaConstant), U8(111),
+ /* 1153 E> */ B(Star), R(0),
+ /* 1161 S> */ B(LdaConstant), U8(112),
+ /* 1163 E> */ B(Star), R(0),
+ /* 1171 S> */ B(LdaConstant), U8(113),
+ /* 1173 E> */ B(Star), R(0),
+ /* 1181 S> */ B(LdaConstant), U8(114),
+ /* 1183 E> */ B(Star), R(0),
+ /* 1191 S> */ B(LdaConstant), U8(115),
+ /* 1193 E> */ B(Star), R(0),
+ /* 1201 S> */ B(LdaConstant), U8(116),
+ /* 1203 E> */ B(Star), R(0),
+ /* 1211 S> */ B(LdaConstant), U8(117),
+ /* 1213 E> */ B(Star), R(0),
+ /* 1221 S> */ B(LdaConstant), U8(118),
+ /* 1223 E> */ B(Star), R(0),
+ /* 1231 S> */ B(LdaConstant), U8(119),
+ /* 1233 E> */ B(Star), R(0),
+ /* 1241 S> */ B(LdaConstant), U8(120),
+ /* 1243 E> */ B(Star), R(0),
+ /* 1251 S> */ B(LdaConstant), U8(121),
+ /* 1253 E> */ B(Star), R(0),
+ /* 1261 S> */ B(LdaConstant), U8(122),
+ /* 1263 E> */ B(Star), R(0),
+ /* 1271 S> */ B(LdaConstant), U8(123),
+ /* 1273 E> */ B(Star), R(0),
+ /* 1281 S> */ B(LdaConstant), U8(124),
+ /* 1283 E> */ B(Star), R(0),
+ /* 1291 S> */ B(LdaConstant), U8(125),
+ /* 1293 E> */ B(Star), R(0),
+ /* 1301 S> */ B(LdaConstant), U8(126),
+ /* 1303 E> */ B(Star), R(0),
+ /* 1311 S> */ B(LdaConstant), U8(127),
+ /* 1313 E> */ B(Star), R(0),
+ /* 1321 S> */ B(LdaConstant), U8(128),
+ /* 1323 E> */ B(Star), R(0),
+ /* 1331 S> */ B(LdaConstant), U8(129),
+ /* 1333 E> */ B(Star), R(0),
+ /* 1341 S> */ B(LdaConstant), U8(130),
+ /* 1343 E> */ B(Star), R(0),
+ /* 1351 S> */ B(LdaConstant), U8(131),
+ /* 1353 E> */ B(Star), R(0),
+ /* 1361 S> */ B(LdaConstant), U8(132),
+ /* 1363 E> */ B(Star), R(0),
+ /* 1371 S> */ B(LdaConstant), U8(133),
+ /* 1373 E> */ B(Star), R(0),
+ /* 1381 S> */ B(LdaConstant), U8(134),
+ /* 1383 E> */ B(Star), R(0),
+ /* 1391 S> */ B(LdaConstant), U8(135),
+ /* 1393 E> */ B(Star), R(0),
+ /* 1401 S> */ B(LdaConstant), U8(136),
+ /* 1403 E> */ B(Star), R(0),
+ /* 1411 S> */ B(LdaConstant), U8(137),
+ /* 1413 E> */ B(Star), R(0),
+ /* 1421 S> */ B(LdaConstant), U8(138),
+ /* 1423 E> */ B(Star), R(0),
+ /* 1431 S> */ B(LdaConstant), U8(139),
+ /* 1433 E> */ B(Star), R(0),
+ /* 1441 S> */ B(LdaConstant), U8(140),
+ /* 1443 E> */ B(Star), R(0),
+ /* 1451 S> */ B(LdaConstant), U8(141),
+ /* 1453 E> */ B(Star), R(0),
+ /* 1461 S> */ B(LdaConstant), U8(142),
+ /* 1463 E> */ B(Star), R(0),
+ /* 1471 S> */ B(LdaConstant), U8(143),
+ /* 1473 E> */ B(Star), R(0),
+ /* 1481 S> */ B(LdaConstant), U8(144),
+ /* 1483 E> */ B(Star), R(0),
+ /* 1491 S> */ B(LdaConstant), U8(145),
+ /* 1493 E> */ B(Star), R(0),
+ /* 1501 S> */ B(LdaConstant), U8(146),
+ /* 1503 E> */ B(Star), R(0),
+ /* 1511 S> */ B(LdaConstant), U8(147),
+ /* 1513 E> */ B(Star), R(0),
+ /* 1521 S> */ B(LdaConstant), U8(148),
+ /* 1523 E> */ B(Star), R(0),
+ /* 1531 S> */ B(LdaConstant), U8(149),
+ /* 1533 E> */ B(Star), R(0),
+ /* 1541 S> */ B(LdaConstant), U8(150),
+ /* 1543 E> */ B(Star), R(0),
+ /* 1551 S> */ B(LdaConstant), U8(151),
+ /* 1553 E> */ B(Star), R(0),
+ /* 1561 S> */ B(LdaConstant), U8(152),
+ /* 1563 E> */ B(Star), R(0),
+ /* 1571 S> */ B(LdaConstant), U8(153),
+ /* 1573 E> */ B(Star), R(0),
+ /* 1581 S> */ B(LdaConstant), U8(154),
+ /* 1583 E> */ B(Star), R(0),
+ /* 1591 S> */ B(LdaConstant), U8(155),
+ /* 1593 E> */ B(Star), R(0),
+ /* 1601 S> */ B(LdaConstant), U8(156),
+ /* 1603 E> */ B(Star), R(0),
+ /* 1611 S> */ B(LdaConstant), U8(157),
+ /* 1613 E> */ B(Star), R(0),
+ /* 1621 S> */ B(LdaConstant), U8(158),
+ /* 1623 E> */ B(Star), R(0),
+ /* 1631 S> */ B(LdaConstant), U8(159),
+ /* 1633 E> */ B(Star), R(0),
+ /* 1641 S> */ B(LdaConstant), U8(160),
+ /* 1643 E> */ B(Star), R(0),
+ /* 1651 S> */ B(LdaConstant), U8(161),
+ /* 1653 E> */ B(Star), R(0),
+ /* 1661 S> */ B(LdaConstant), U8(162),
+ /* 1663 E> */ B(Star), R(0),
+ /* 1671 S> */ B(LdaConstant), U8(163),
+ /* 1673 E> */ B(Star), R(0),
+ /* 1681 S> */ B(LdaConstant), U8(164),
+ /* 1683 E> */ B(Star), R(0),
+ /* 1691 S> */ B(LdaConstant), U8(165),
+ /* 1693 E> */ B(Star), R(0),
+ /* 1701 S> */ B(LdaConstant), U8(166),
+ /* 1703 E> */ B(Star), R(0),
+ /* 1711 S> */ B(LdaConstant), U8(167),
+ /* 1713 E> */ B(Star), R(0),
+ /* 1721 S> */ B(LdaConstant), U8(168),
+ /* 1723 E> */ B(Star), R(0),
+ /* 1731 S> */ B(LdaConstant), U8(169),
+ /* 1733 E> */ B(Star), R(0),
+ /* 1741 S> */ B(LdaConstant), U8(170),
+ /* 1743 E> */ B(Star), R(0),
+ /* 1751 S> */ B(LdaConstant), U8(171),
+ /* 1753 E> */ B(Star), R(0),
+ /* 1761 S> */ B(LdaConstant), U8(172),
+ /* 1763 E> */ B(Star), R(0),
+ /* 1771 S> */ B(LdaConstant), U8(173),
+ /* 1773 E> */ B(Star), R(0),
+ /* 1781 S> */ B(LdaConstant), U8(174),
+ /* 1783 E> */ B(Star), R(0),
+ /* 1791 S> */ B(LdaConstant), U8(175),
+ /* 1793 E> */ B(Star), R(0),
+ /* 1801 S> */ B(LdaConstant), U8(176),
+ /* 1803 E> */ B(Star), R(0),
+ /* 1811 S> */ B(LdaConstant), U8(177),
+ /* 1813 E> */ B(Star), R(0),
+ /* 1821 S> */ B(LdaConstant), U8(178),
+ /* 1823 E> */ B(Star), R(0),
+ /* 1831 S> */ B(LdaConstant), U8(179),
+ /* 1833 E> */ B(Star), R(0),
+ /* 1841 S> */ B(LdaConstant), U8(180),
+ /* 1843 E> */ B(Star), R(0),
+ /* 1851 S> */ B(LdaConstant), U8(181),
+ /* 1853 E> */ B(Star), R(0),
+ /* 1861 S> */ B(LdaConstant), U8(182),
+ /* 1863 E> */ B(Star), R(0),
+ /* 1871 S> */ B(LdaConstant), U8(183),
+ /* 1873 E> */ B(Star), R(0),
+ /* 1881 S> */ B(LdaConstant), U8(184),
+ /* 1883 E> */ B(Star), R(0),
+ /* 1891 S> */ B(LdaConstant), U8(185),
+ /* 1893 E> */ B(Star), R(0),
+ /* 1901 S> */ B(LdaConstant), U8(186),
+ /* 1903 E> */ B(Star), R(0),
+ /* 1911 S> */ B(LdaConstant), U8(187),
+ /* 1913 E> */ B(Star), R(0),
+ /* 1921 S> */ B(LdaConstant), U8(188),
+ /* 1923 E> */ B(Star), R(0),
+ /* 1931 S> */ B(LdaConstant), U8(189),
+ /* 1933 E> */ B(Star), R(0),
+ /* 1941 S> */ B(LdaConstant), U8(190),
+ /* 1943 E> */ B(Star), R(0),
+ /* 1951 S> */ B(LdaConstant), U8(191),
+ /* 1953 E> */ B(Star), R(0),
+ /* 1961 S> */ B(LdaConstant), U8(192),
+ /* 1963 E> */ B(Star), R(0),
+ /* 1971 S> */ B(LdaConstant), U8(193),
+ /* 1973 E> */ B(Star), R(0),
+ /* 1981 S> */ B(LdaConstant), U8(194),
+ /* 1983 E> */ B(Star), R(0),
+ /* 1991 S> */ B(LdaConstant), U8(195),
+ /* 1993 E> */ B(Star), R(0),
+ /* 2001 S> */ B(LdaConstant), U8(196),
+ /* 2003 E> */ B(Star), R(0),
+ /* 2011 S> */ B(LdaConstant), U8(197),
+ /* 2013 E> */ B(Star), R(0),
+ /* 2021 S> */ B(LdaConstant), U8(198),
+ /* 2023 E> */ B(Star), R(0),
+ /* 2031 S> */ B(LdaConstant), U8(199),
+ /* 2033 E> */ B(Star), R(0),
+ /* 2041 S> */ B(LdaConstant), U8(200),
+ /* 2043 E> */ B(Star), R(0),
+ /* 2051 S> */ B(LdaConstant), U8(201),
+ /* 2053 E> */ B(Star), R(0),
+ /* 2061 S> */ B(LdaConstant), U8(202),
+ /* 2063 E> */ B(Star), R(0),
+ /* 2071 S> */ B(LdaConstant), U8(203),
+ /* 2073 E> */ B(Star), R(0),
+ /* 2081 S> */ B(LdaConstant), U8(204),
+ /* 2083 E> */ B(Star), R(0),
+ /* 2091 S> */ B(LdaConstant), U8(205),
+ /* 2093 E> */ B(Star), R(0),
+ /* 2101 S> */ B(LdaConstant), U8(206),
+ /* 2103 E> */ B(Star), R(0),
+ /* 2111 S> */ B(LdaConstant), U8(207),
+ /* 2113 E> */ B(Star), R(0),
+ /* 2121 S> */ B(LdaConstant), U8(208),
+ /* 2123 E> */ B(Star), R(0),
+ /* 2131 S> */ B(LdaConstant), U8(209),
+ /* 2133 E> */ B(Star), R(0),
+ /* 2141 S> */ B(LdaConstant), U8(210),
+ /* 2143 E> */ B(Star), R(0),
+ /* 2151 S> */ B(LdaConstant), U8(211),
+ /* 2153 E> */ B(Star), R(0),
+ /* 2161 S> */ B(LdaConstant), U8(212),
+ /* 2163 E> */ B(Star), R(0),
+ /* 2171 S> */ B(LdaConstant), U8(213),
+ /* 2173 E> */ B(Star), R(0),
+ /* 2181 S> */ B(LdaConstant), U8(214),
+ /* 2183 E> */ B(Star), R(0),
+ /* 2191 S> */ B(LdaConstant), U8(215),
+ /* 2193 E> */ B(Star), R(0),
+ /* 2201 S> */ B(LdaConstant), U8(216),
+ /* 2203 E> */ B(Star), R(0),
+ /* 2211 S> */ B(LdaConstant), U8(217),
+ /* 2213 E> */ B(Star), R(0),
+ /* 2221 S> */ B(LdaConstant), U8(218),
+ /* 2223 E> */ B(Star), R(0),
+ /* 2231 S> */ B(LdaConstant), U8(219),
+ /* 2233 E> */ B(Star), R(0),
+ /* 2241 S> */ B(LdaConstant), U8(220),
+ /* 2243 E> */ B(Star), R(0),
+ /* 2251 S> */ B(LdaConstant), U8(221),
+ /* 2253 E> */ B(Star), R(0),
+ /* 2261 S> */ B(LdaConstant), U8(222),
+ /* 2263 E> */ B(Star), R(0),
+ /* 2271 S> */ B(LdaConstant), U8(223),
+ /* 2273 E> */ B(Star), R(0),
+ /* 2281 S> */ B(LdaConstant), U8(224),
+ /* 2283 E> */ B(Star), R(0),
+ /* 2291 S> */ B(LdaConstant), U8(225),
+ /* 2293 E> */ B(Star), R(0),
+ /* 2301 S> */ B(LdaConstant), U8(226),
+ /* 2303 E> */ B(Star), R(0),
+ /* 2311 S> */ B(LdaConstant), U8(227),
+ /* 2313 E> */ B(Star), R(0),
+ /* 2321 S> */ B(LdaConstant), U8(228),
+ /* 2323 E> */ B(Star), R(0),
+ /* 2331 S> */ B(LdaConstant), U8(229),
+ /* 2333 E> */ B(Star), R(0),
+ /* 2341 S> */ B(LdaConstant), U8(230),
+ /* 2343 E> */ B(Star), R(0),
+ /* 2351 S> */ B(LdaConstant), U8(231),
+ /* 2353 E> */ B(Star), R(0),
+ /* 2361 S> */ B(LdaConstant), U8(232),
+ /* 2363 E> */ B(Star), R(0),
+ /* 2371 S> */ B(LdaConstant), U8(233),
+ /* 2373 E> */ B(Star), R(0),
+ /* 2381 S> */ B(LdaConstant), U8(234),
+ /* 2383 E> */ B(Star), R(0),
+ /* 2391 S> */ B(LdaConstant), U8(235),
+ /* 2393 E> */ B(Star), R(0),
+ /* 2401 S> */ B(LdaConstant), U8(236),
+ /* 2403 E> */ B(Star), R(0),
+ /* 2411 S> */ B(LdaConstant), U8(237),
+ /* 2413 E> */ B(Star), R(0),
+ /* 2421 S> */ B(LdaConstant), U8(238),
+ /* 2423 E> */ B(Star), R(0),
+ /* 2431 S> */ B(LdaConstant), U8(239),
+ /* 2433 E> */ B(Star), R(0),
+ /* 2441 S> */ B(LdaConstant), U8(240),
+ /* 2443 E> */ B(Star), R(0),
+ /* 2451 S> */ B(LdaConstant), U8(241),
+ /* 2453 E> */ B(Star), R(0),
+ /* 2461 S> */ B(LdaConstant), U8(242),
+ /* 2463 E> */ B(Star), R(0),
+ /* 2471 S> */ B(LdaConstant), U8(243),
+ /* 2473 E> */ B(Star), R(0),
+ /* 2481 S> */ B(LdaConstant), U8(244),
+ /* 2483 E> */ B(Star), R(0),
+ /* 2491 S> */ B(LdaConstant), U8(245),
+ /* 2493 E> */ B(Star), R(0),
+ /* 2501 S> */ B(LdaConstant), U8(246),
+ /* 2503 E> */ B(Star), R(0),
+ /* 2511 S> */ B(LdaConstant), U8(247),
+ /* 2513 E> */ B(Star), R(0),
+ /* 2521 S> */ B(LdaConstant), U8(248),
+ /* 2523 E> */ B(Star), R(0),
+ /* 2531 S> */ B(LdaConstant), U8(249),
+ /* 2533 E> */ B(Star), R(0),
+ /* 2541 S> */ B(LdaConstant), U8(250),
+ /* 2543 E> */ B(Star), R(0),
+ /* 2551 S> */ B(LdaConstant), U8(251),
+ /* 2553 E> */ B(Star), R(0),
+ /* 2561 S> */ B(LdaConstant), U8(252),
+ /* 2563 E> */ B(Star), R(0),
+ /* 2571 S> */ B(LdaConstant), U8(253),
+ /* 2573 E> */ B(Star), R(0),
+ /* 2581 S> */ B(LdaConstant), U8(254),
+ /* 2583 E> */ B(Star), R(0),
+ /* 2591 S> */ B(LdaConstant), U8(255),
+ /* 2593 E> */ B(Star), R(0),
+ /* 2601 S> */ B(Wide), B(CreateObjectLiteral), U16(256), U16(0), U8(1),
+ B(Star), R(1),
+ /* 2638 S> */ B(Return),
]
constant pool: [
InstanceType::HEAP_NUMBER_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/OuterContextVariables.golden b/test/cctest/interpreter/bytecode_expectations/OuterContextVariables.golden
index 378a5b7..af6e942 100644
--- a/test/cctest/interpreter/bytecode_expectations/OuterContextVariables.golden
+++ b/test/cctest/interpreter/bytecode_expectations/OuterContextVariables.golden
@@ -24,16 +24,16 @@
parameter count: 1
bytecode array length: 21
bytecodes: [
- B(StackCheck),
- B(Ldar), R(context),
- B(Star), R(0),
- B(LdaContextSlot), R(0), U8(1),
- B(Star), R(0),
- B(LdaContextSlot), R(0), U8(4),
- B(Star), R(1),
- B(LdaContextSlot), R(context), U8(4),
- B(Mul), R(1),
- B(Return),
+ /* 97 E> */ B(StackCheck),
+ /* 102 S> */ B(Ldar), R(context),
+ B(Star), R(0),
+ B(LdaContextSlot), R(0), U8(1),
+ B(Star), R(0),
+ B(LdaContextSlot), R(0), U8(4),
+ B(Star), R(1),
+ /* 120 E> */ B(LdaContextSlot), R(context), U8(4),
+ B(Mul), R(1),
+ /* 130 S> */ B(Return),
]
constant pool: [
]
@@ -56,17 +56,17 @@
parameter count: 1
bytecode array length: 22
bytecodes: [
- B(StackCheck),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(0),
- B(Ldar), R(context),
- B(Star), R(1),
- B(LdaContextSlot), R(1), U8(1),
- B(Star), R(1),
- B(Ldar), R(0),
- B(StaContextSlot), R(1), U8(4),
- B(LdaUndefined),
- B(Return),
+ /* 97 E> */ B(StackCheck),
+ /* 102 S> */ B(LdaContextSlot), R(context), U8(4),
+ /* 111 E> */ B(Star), R(0),
+ B(Ldar), R(context),
+ B(Star), R(1),
+ B(LdaContextSlot), R(1), U8(1),
+ B(Star), R(1),
+ B(Ldar), R(0),
+ B(StaContextSlot), R(1), U8(4),
+ B(LdaUndefined),
+ /* 123 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/Parameters.golden b/test/cctest/interpreter/bytecode_expectations/Parameters.golden
index e124788..f26c066 100644
--- a/test/cctest/interpreter/bytecode_expectations/Parameters.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Parameters.golden
@@ -17,9 +17,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(Ldar), R(this),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 15 S> */ B(Ldar), R(this),
+ /* 28 S> */ B(Return),
]
constant pool: [
]
@@ -35,9 +35,9 @@
parameter count: 2
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 19 S> */ B(Ldar), R(arg0),
+ /* 32 S> */ B(Return),
]
constant pool: [
]
@@ -53,9 +53,9 @@
parameter count: 2
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(Ldar), R(this),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 19 S> */ B(Ldar), R(this),
+ /* 32 S> */ B(Return),
]
constant pool: [
]
@@ -71,9 +71,9 @@
parameter count: 8
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg3),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 55 S> */ B(Ldar), R(arg3),
+ /* 68 S> */ B(Return),
]
constant pool: [
]
@@ -89,9 +89,9 @@
parameter count: 8
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(Ldar), R(this),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 55 S> */ B(Ldar), R(this),
+ /* 68 S> */ B(Return),
]
constant pool: [
]
@@ -107,11 +107,11 @@
parameter count: 2
bytecode array length: 7
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(arg0),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 19 S> */ B(LdaSmi), U8(1),
+ /* 24 E> */ B(Star), R(arg0),
+ B(LdaUndefined),
+ /* 29 S> */ B(Return),
]
constant pool: [
]
@@ -127,11 +127,11 @@
parameter count: 5
bytecode array length: 7
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(arg1),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 37 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(arg1),
+ B(LdaUndefined),
+ /* 47 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/PrimitiveExpressions.golden b/test/cctest/interpreter/bytecode_expectations/PrimitiveExpressions.golden
index 08b20dd..b9fd679 100644
--- a/test/cctest/interpreter/bytecode_expectations/PrimitiveExpressions.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PrimitiveExpressions.golden
@@ -15,10 +15,10 @@
parameter count: 1
bytecode array length: 5
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 55 S> */ B(Return),
]
constant pool: [
]
@@ -33,13 +33,13 @@
parameter count: 1
bytecode array length: 11
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Add), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ B(Add), R(1),
+ /* 59 S> */ B(Return),
]
constant pool: [
]
@@ -54,13 +54,13 @@
parameter count: 1
bytecode array length: 11
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Sub), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ B(Sub), R(1),
+ /* 59 S> */ B(Return),
]
constant pool: [
]
@@ -75,13 +75,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(4),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Mul), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(4),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ B(Mul), R(1),
+ /* 59 S> */ B(Return),
]
constant pool: [
]
@@ -96,13 +96,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(4),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Div), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(4),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ B(Div), R(1),
+ /* 59 S> */ B(Return),
]
constant pool: [
]
@@ -117,13 +117,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(4),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Mod), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(4),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ B(Mod), R(1),
+ /* 59 S> */ B(Return),
]
constant pool: [
]
@@ -138,13 +138,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(BitwiseOr), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ B(BitwiseOr), R(1),
+ /* 59 S> */ B(Return),
]
constant pool: [
]
@@ -159,13 +159,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(BitwiseXor), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ B(BitwiseXor), R(1),
+ /* 59 S> */ B(Return),
]
constant pool: [
]
@@ -180,13 +180,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(BitwiseAnd), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ B(BitwiseAnd), R(1),
+ /* 59 S> */ B(Return),
]
constant pool: [
]
@@ -201,13 +201,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(ShiftLeft), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ B(ShiftLeft), R(1),
+ /* 61 S> */ B(Return),
]
constant pool: [
]
@@ -222,13 +222,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(ShiftRight), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ B(ShiftRight), R(1),
+ /* 61 S> */ B(Return),
]
constant pool: [
]
@@ -243,13 +243,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(10),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(ShiftRightLogical), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(10),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ B(ShiftRightLogical), R(1),
+ /* 62 S> */ B(Return),
]
constant pool: [
]
@@ -264,11 +264,11 @@
parameter count: 1
bytecode array length: 7
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaSmi), U8(3),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(3),
+ /* 60 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/PrimitiveReturnStatements.golden b/test/cctest/interpreter/bytecode_expectations/PrimitiveReturnStatements.golden
index 0a23f2b..a707451 100644
--- a/test/cctest/interpreter/bytecode_expectations/PrimitiveReturnStatements.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PrimitiveReturnStatements.golden
@@ -14,9 +14,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ B(LdaUndefined),
+ /* 34 S> */ B(Return),
]
constant pool: [
]
@@ -31,9 +31,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaUndefined),
+ /* 42 S> */ B(Return),
]
constant pool: [
]
@@ -48,9 +48,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaNull),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaNull),
+ /* 47 S> */ B(Return),
]
constant pool: [
]
@@ -65,9 +65,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaTrue),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaTrue),
+ /* 47 S> */ B(Return),
]
constant pool: [
]
@@ -82,9 +82,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaFalse),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaFalse),
+ /* 48 S> */ B(Return),
]
constant pool: [
]
@@ -99,9 +99,9 @@
parameter count: 1
bytecode array length: 3
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaZero),
+ /* 44 S> */ B(Return),
]
constant pool: [
]
@@ -116,9 +116,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaSmi), U8(1),
+ /* 45 S> */ B(Return),
]
constant pool: [
]
@@ -133,9 +133,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(-1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaSmi), U8(-1),
+ /* 45 S> */ B(Return),
]
constant pool: [
]
@@ -150,9 +150,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(127),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaSmi), U8(127),
+ /* 47 S> */ B(Return),
]
constant pool: [
]
@@ -167,9 +167,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(-128),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaSmi), U8(-128),
+ /* 47 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/PropertyCall.golden b/test/cctest/interpreter/bytecode_expectations/PropertyCall.golden
index d6108f1..df4c277 100644
--- a/test/cctest/interpreter/bytecode_expectations/PropertyCall.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PropertyCall.golden
@@ -17,13 +17,13 @@
parameter count: 2
bytecode array length: 17
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(3),
- B(Star), R(0),
- B(Call), R(0), R(1), U8(1), U8(1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 16 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 24 E> */ B(LoadIC), R(1), U8(0), U8(3),
+ B(Star), R(0),
+ /* 25 E> */ B(Call), R(0), R(1), U8(1), U8(1),
+ /* 33 S> */ B(Return),
]
constant pool: [
"func",
@@ -40,17 +40,17 @@
parameter count: 4
bytecode array length: 25
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(3),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(2),
- B(Ldar), R(arg2),
- B(Star), R(3),
- B(Call), R(0), R(1), U8(3), U8(1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 22 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 30 E> */ B(LoadIC), R(1), U8(0), U8(3),
+ B(Star), R(0),
+ /* 36 E> */ B(Ldar), R(arg1),
+ B(Star), R(2),
+ /* 39 E> */ B(Ldar), R(arg2),
+ B(Star), R(3),
+ /* 31 E> */ B(Call), R(0), R(1), U8(3), U8(1),
+ /* 43 S> */ B(Return),
]
constant pool: [
"func",
@@ -67,20 +67,20 @@
parameter count: 3
bytecode array length: 31
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(3),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(3),
- B(Ldar), R(arg1),
- B(Add), R(3),
- B(Star), R(2),
- B(Ldar), R(arg1),
- B(Star), R(3),
- B(Call), R(0), R(1), U8(3), U8(1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 19 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 27 E> */ B(LoadIC), R(1), U8(0), U8(3),
+ B(Star), R(0),
+ /* 33 E> */ B(Ldar), R(arg1),
+ B(Star), R(3),
+ /* 37 E> */ B(Ldar), R(arg1),
+ B(Add), R(3),
+ B(Star), R(2),
+ /* 40 E> */ B(Ldar), R(arg1),
+ B(Star), R(3),
+ /* 28 E> */ B(Call), R(0), R(1), U8(3), U8(1),
+ /* 44 S> */ B(Return),
]
constant pool: [
"func",
@@ -226,397 +226,397 @@
parameter count: 2
bytecode array length: 1050
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(1),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(3),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(5),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(7),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(9),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(11),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(13),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(15),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(17),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(19),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(21),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(23),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(25),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(27),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(29),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(31),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(33),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(35),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(37),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(39),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(41),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(43),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(45),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(47),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(49),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(51),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(53),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(55),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(57),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(59),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(61),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(63),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(65),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(67),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(69),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(71),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(73),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(75),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(77),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(79),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(81),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(83),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(85),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(87),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(89),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(91),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(93),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(95),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(97),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(99),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(101),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(103),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(105),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(107),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(109),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(111),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(113),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(115),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(117),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(119),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(121),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(123),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(125),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(127),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(129),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(131),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(133),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(135),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(137),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(139),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(141),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(143),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(145),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(147),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(149),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(151),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(153),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(155),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(157),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(159),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(161),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(163),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(165),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(167),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(169),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(171),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(173),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(175),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(177),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(179),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(181),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(183),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(185),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(187),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(189),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(191),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(193),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(195),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(197),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(199),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(201),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(203),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(205),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(207),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(209),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(211),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(213),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(215),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(217),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(219),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(221),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(223),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(225),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(227),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(229),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(231),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(233),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(235),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(237),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(239),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(241),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(243),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(245),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(247),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(249),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(251),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(253),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(255),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Wide), B(LoadIC), R16(1), U16(0), U16(259),
- B(Star), R(0),
- B(Wide), B(Call), R16(0), R16(1), U16(1), U16(257),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 17 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 18 E> */ B(LoadIC), R(0), U8(0), U8(1),
+ /* 26 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 27 E> */ B(LoadIC), R(0), U8(0), U8(3),
+ /* 35 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 36 E> */ B(LoadIC), R(0), U8(0), U8(5),
+ /* 44 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 45 E> */ B(LoadIC), R(0), U8(0), U8(7),
+ /* 53 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 54 E> */ B(LoadIC), R(0), U8(0), U8(9),
+ /* 62 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 63 E> */ B(LoadIC), R(0), U8(0), U8(11),
+ /* 71 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 72 E> */ B(LoadIC), R(0), U8(0), U8(13),
+ /* 80 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 81 E> */ B(LoadIC), R(0), U8(0), U8(15),
+ /* 89 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 90 E> */ B(LoadIC), R(0), U8(0), U8(17),
+ /* 98 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 99 E> */ B(LoadIC), R(0), U8(0), U8(19),
+ /* 107 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 108 E> */ B(LoadIC), R(0), U8(0), U8(21),
+ /* 116 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 117 E> */ B(LoadIC), R(0), U8(0), U8(23),
+ /* 125 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 126 E> */ B(LoadIC), R(0), U8(0), U8(25),
+ /* 134 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 135 E> */ B(LoadIC), R(0), U8(0), U8(27),
+ /* 143 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 144 E> */ B(LoadIC), R(0), U8(0), U8(29),
+ /* 152 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 153 E> */ B(LoadIC), R(0), U8(0), U8(31),
+ /* 161 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 162 E> */ B(LoadIC), R(0), U8(0), U8(33),
+ /* 170 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 171 E> */ B(LoadIC), R(0), U8(0), U8(35),
+ /* 179 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 180 E> */ B(LoadIC), R(0), U8(0), U8(37),
+ /* 188 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 189 E> */ B(LoadIC), R(0), U8(0), U8(39),
+ /* 197 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 198 E> */ B(LoadIC), R(0), U8(0), U8(41),
+ /* 206 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 207 E> */ B(LoadIC), R(0), U8(0), U8(43),
+ /* 215 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 216 E> */ B(LoadIC), R(0), U8(0), U8(45),
+ /* 224 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 225 E> */ B(LoadIC), R(0), U8(0), U8(47),
+ /* 233 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 234 E> */ B(LoadIC), R(0), U8(0), U8(49),
+ /* 242 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 243 E> */ B(LoadIC), R(0), U8(0), U8(51),
+ /* 251 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 252 E> */ B(LoadIC), R(0), U8(0), U8(53),
+ /* 260 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 261 E> */ B(LoadIC), R(0), U8(0), U8(55),
+ /* 269 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 270 E> */ B(LoadIC), R(0), U8(0), U8(57),
+ /* 278 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 279 E> */ B(LoadIC), R(0), U8(0), U8(59),
+ /* 287 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 288 E> */ B(LoadIC), R(0), U8(0), U8(61),
+ /* 296 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 297 E> */ B(LoadIC), R(0), U8(0), U8(63),
+ /* 305 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 306 E> */ B(LoadIC), R(0), U8(0), U8(65),
+ /* 314 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 315 E> */ B(LoadIC), R(0), U8(0), U8(67),
+ /* 323 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 324 E> */ B(LoadIC), R(0), U8(0), U8(69),
+ /* 332 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 333 E> */ B(LoadIC), R(0), U8(0), U8(71),
+ /* 341 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 342 E> */ B(LoadIC), R(0), U8(0), U8(73),
+ /* 350 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 351 E> */ B(LoadIC), R(0), U8(0), U8(75),
+ /* 359 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 360 E> */ B(LoadIC), R(0), U8(0), U8(77),
+ /* 368 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 369 E> */ B(LoadIC), R(0), U8(0), U8(79),
+ /* 377 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 378 E> */ B(LoadIC), R(0), U8(0), U8(81),
+ /* 386 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 387 E> */ B(LoadIC), R(0), U8(0), U8(83),
+ /* 395 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 396 E> */ B(LoadIC), R(0), U8(0), U8(85),
+ /* 404 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 405 E> */ B(LoadIC), R(0), U8(0), U8(87),
+ /* 413 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 414 E> */ B(LoadIC), R(0), U8(0), U8(89),
+ /* 422 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 423 E> */ B(LoadIC), R(0), U8(0), U8(91),
+ /* 431 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 432 E> */ B(LoadIC), R(0), U8(0), U8(93),
+ /* 440 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 441 E> */ B(LoadIC), R(0), U8(0), U8(95),
+ /* 449 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 450 E> */ B(LoadIC), R(0), U8(0), U8(97),
+ /* 458 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 459 E> */ B(LoadIC), R(0), U8(0), U8(99),
+ /* 467 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 468 E> */ B(LoadIC), R(0), U8(0), U8(101),
+ /* 476 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 477 E> */ B(LoadIC), R(0), U8(0), U8(103),
+ /* 485 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 486 E> */ B(LoadIC), R(0), U8(0), U8(105),
+ /* 494 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 495 E> */ B(LoadIC), R(0), U8(0), U8(107),
+ /* 503 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 504 E> */ B(LoadIC), R(0), U8(0), U8(109),
+ /* 512 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 513 E> */ B(LoadIC), R(0), U8(0), U8(111),
+ /* 521 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 522 E> */ B(LoadIC), R(0), U8(0), U8(113),
+ /* 530 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 531 E> */ B(LoadIC), R(0), U8(0), U8(115),
+ /* 539 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 540 E> */ B(LoadIC), R(0), U8(0), U8(117),
+ /* 548 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 549 E> */ B(LoadIC), R(0), U8(0), U8(119),
+ /* 557 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 558 E> */ B(LoadIC), R(0), U8(0), U8(121),
+ /* 566 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 567 E> */ B(LoadIC), R(0), U8(0), U8(123),
+ /* 575 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 576 E> */ B(LoadIC), R(0), U8(0), U8(125),
+ /* 584 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 585 E> */ B(LoadIC), R(0), U8(0), U8(127),
+ /* 593 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 594 E> */ B(LoadIC), R(0), U8(0), U8(129),
+ /* 602 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 603 E> */ B(LoadIC), R(0), U8(0), U8(131),
+ /* 611 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 612 E> */ B(LoadIC), R(0), U8(0), U8(133),
+ /* 620 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 621 E> */ B(LoadIC), R(0), U8(0), U8(135),
+ /* 629 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 630 E> */ B(LoadIC), R(0), U8(0), U8(137),
+ /* 638 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 639 E> */ B(LoadIC), R(0), U8(0), U8(139),
+ /* 647 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 648 E> */ B(LoadIC), R(0), U8(0), U8(141),
+ /* 656 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 657 E> */ B(LoadIC), R(0), U8(0), U8(143),
+ /* 665 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 666 E> */ B(LoadIC), R(0), U8(0), U8(145),
+ /* 674 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 675 E> */ B(LoadIC), R(0), U8(0), U8(147),
+ /* 683 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 684 E> */ B(LoadIC), R(0), U8(0), U8(149),
+ /* 692 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 693 E> */ B(LoadIC), R(0), U8(0), U8(151),
+ /* 701 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 702 E> */ B(LoadIC), R(0), U8(0), U8(153),
+ /* 710 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 711 E> */ B(LoadIC), R(0), U8(0), U8(155),
+ /* 719 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 720 E> */ B(LoadIC), R(0), U8(0), U8(157),
+ /* 728 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 729 E> */ B(LoadIC), R(0), U8(0), U8(159),
+ /* 737 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 738 E> */ B(LoadIC), R(0), U8(0), U8(161),
+ /* 746 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 747 E> */ B(LoadIC), R(0), U8(0), U8(163),
+ /* 755 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 756 E> */ B(LoadIC), R(0), U8(0), U8(165),
+ /* 764 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 765 E> */ B(LoadIC), R(0), U8(0), U8(167),
+ /* 773 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 774 E> */ B(LoadIC), R(0), U8(0), U8(169),
+ /* 782 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 783 E> */ B(LoadIC), R(0), U8(0), U8(171),
+ /* 791 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 792 E> */ B(LoadIC), R(0), U8(0), U8(173),
+ /* 800 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 801 E> */ B(LoadIC), R(0), U8(0), U8(175),
+ /* 809 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 810 E> */ B(LoadIC), R(0), U8(0), U8(177),
+ /* 818 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 819 E> */ B(LoadIC), R(0), U8(0), U8(179),
+ /* 827 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 828 E> */ B(LoadIC), R(0), U8(0), U8(181),
+ /* 836 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 837 E> */ B(LoadIC), R(0), U8(0), U8(183),
+ /* 845 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 846 E> */ B(LoadIC), R(0), U8(0), U8(185),
+ /* 854 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 855 E> */ B(LoadIC), R(0), U8(0), U8(187),
+ /* 863 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 864 E> */ B(LoadIC), R(0), U8(0), U8(189),
+ /* 872 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 873 E> */ B(LoadIC), R(0), U8(0), U8(191),
+ /* 881 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 882 E> */ B(LoadIC), R(0), U8(0), U8(193),
+ /* 890 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 891 E> */ B(LoadIC), R(0), U8(0), U8(195),
+ /* 899 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 900 E> */ B(LoadIC), R(0), U8(0), U8(197),
+ /* 908 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 909 E> */ B(LoadIC), R(0), U8(0), U8(199),
+ /* 917 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 918 E> */ B(LoadIC), R(0), U8(0), U8(201),
+ /* 926 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 927 E> */ B(LoadIC), R(0), U8(0), U8(203),
+ /* 935 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 936 E> */ B(LoadIC), R(0), U8(0), U8(205),
+ /* 944 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 945 E> */ B(LoadIC), R(0), U8(0), U8(207),
+ /* 953 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 954 E> */ B(LoadIC), R(0), U8(0), U8(209),
+ /* 962 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 963 E> */ B(LoadIC), R(0), U8(0), U8(211),
+ /* 971 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 972 E> */ B(LoadIC), R(0), U8(0), U8(213),
+ /* 980 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 981 E> */ B(LoadIC), R(0), U8(0), U8(215),
+ /* 989 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 990 E> */ B(LoadIC), R(0), U8(0), U8(217),
+ /* 998 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 999 E> */ B(LoadIC), R(0), U8(0), U8(219),
+ /* 1007 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1008 E> */ B(LoadIC), R(0), U8(0), U8(221),
+ /* 1016 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1017 E> */ B(LoadIC), R(0), U8(0), U8(223),
+ /* 1025 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1026 E> */ B(LoadIC), R(0), U8(0), U8(225),
+ /* 1034 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1035 E> */ B(LoadIC), R(0), U8(0), U8(227),
+ /* 1043 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1044 E> */ B(LoadIC), R(0), U8(0), U8(229),
+ /* 1052 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1053 E> */ B(LoadIC), R(0), U8(0), U8(231),
+ /* 1061 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1062 E> */ B(LoadIC), R(0), U8(0), U8(233),
+ /* 1070 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1071 E> */ B(LoadIC), R(0), U8(0), U8(235),
+ /* 1079 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1080 E> */ B(LoadIC), R(0), U8(0), U8(237),
+ /* 1088 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1089 E> */ B(LoadIC), R(0), U8(0), U8(239),
+ /* 1097 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1098 E> */ B(LoadIC), R(0), U8(0), U8(241),
+ /* 1106 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1107 E> */ B(LoadIC), R(0), U8(0), U8(243),
+ /* 1115 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1116 E> */ B(LoadIC), R(0), U8(0), U8(245),
+ /* 1124 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1125 E> */ B(LoadIC), R(0), U8(0), U8(247),
+ /* 1133 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1134 E> */ B(LoadIC), R(0), U8(0), U8(249),
+ /* 1142 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1143 E> */ B(LoadIC), R(0), U8(0), U8(251),
+ /* 1151 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1152 E> */ B(LoadIC), R(0), U8(0), U8(253),
+ /* 1160 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1161 E> */ B(LoadIC), R(0), U8(0), U8(255),
+ /* 1169 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1177 E> */ B(Wide), B(LoadIC), R16(1), U16(0), U16(259),
+ B(Star), R(0),
+ /* 1178 E> */ B(Wide), B(Call), R16(0), R16(1), U16(1), U16(257),
+ /* 1186 S> */ B(Return),
]
constant pool: [
"func",
diff --git a/test/cctest/interpreter/bytecode_expectations/PropertyLoads.golden b/test/cctest/interpreter/bytecode_expectations/PropertyLoads.golden
index 7d5a58e..76741cb 100644
--- a/test/cctest/interpreter/bytecode_expectations/PropertyLoads.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PropertyLoads.golden
@@ -17,11 +17,11 @@
parameter count: 2
bytecode array length: 10
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 16 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 24 E> */ B(LoadIC), R(0), U8(0), U8(1),
+ /* 31 S> */ B(Return),
]
constant pool: [
"name",
@@ -38,11 +38,11 @@
parameter count: 2
bytecode array length: 10
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 16 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 24 E> */ B(LoadIC), R(0), U8(0), U8(1),
+ /* 33 S> */ B(Return),
]
constant pool: [
"key",
@@ -59,12 +59,12 @@
parameter count: 2
bytecode array length: 11
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(100),
- B(KeyedLoadIC), R(0), U8(1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 16 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 24 E> */ B(LdaSmi), U8(100),
+ B(KeyedLoadIC), R(0), U8(1),
+ /* 31 S> */ B(Return),
]
constant pool: [
]
@@ -80,12 +80,12 @@
parameter count: 3
bytecode array length: 11
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(0), U8(1),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 19 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 27 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(0), U8(1),
+ /* 32 S> */ B(Return),
]
constant pool: [
]
@@ -101,16 +101,16 @@
parameter count: 2
bytecode array length: 21
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(1),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LdaSmi), U8(-124),
- B(KeyedLoadIC), R(1), U8(3),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 25 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 25 E> */ B(LoadIC), R(1), U8(0), U8(1),
+ /* 25 E> */ B(Star), R(0),
+ /* 32 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 40 E> */ B(LdaSmi), U8(-124),
+ B(KeyedLoadIC), R(1), U8(3),
+ /* 48 S> */ B(Return),
]
constant pool: [
"name",
@@ -258,523 +258,523 @@
parameter count: 2
bytecode array length: 1294
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(1),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(3),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(5),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(7),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(9),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(11),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(13),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(15),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(17),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(19),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(21),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(23),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(25),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(27),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(29),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(31),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(33),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(35),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(37),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(39),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(41),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(43),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(45),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(47),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(49),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(51),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(53),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(55),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(57),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(59),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(61),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(63),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(65),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(67),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(69),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(71),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(73),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(75),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(77),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(79),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(81),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(83),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(85),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(87),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(89),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(91),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(93),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(95),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(97),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(99),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(101),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(103),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(105),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(107),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(109),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(111),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(113),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(115),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(117),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(119),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(121),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(123),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(125),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(127),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(129),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(131),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(133),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(135),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(137),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(139),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(141),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(143),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(145),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(147),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(149),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(151),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(153),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(155),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(157),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(159),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(161),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(163),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(165),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(167),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(169),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(171),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(173),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(175),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(177),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(179),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(181),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(183),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(185),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(187),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(189),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(191),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(193),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(195),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(197),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(199),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(201),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(203),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(205),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(207),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(209),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(211),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(213),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(215),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(217),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(219),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(221),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(223),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(225),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(227),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(229),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(231),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(233),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(235),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(237),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(239),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(241),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(243),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(245),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(247),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(249),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(251),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(253),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(0), U8(255),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Wide), B(LoadIC), R16(1), U16(0), U16(257),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 27 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 32 E> */ B(LoadIC), R(1), U8(0), U8(1),
+ /* 29 E> */ B(Star), R(0),
+ /* 41 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 46 E> */ B(LoadIC), R(1), U8(0), U8(3),
+ /* 43 E> */ B(Star), R(0),
+ /* 55 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 60 E> */ B(LoadIC), R(1), U8(0), U8(5),
+ /* 57 E> */ B(Star), R(0),
+ /* 69 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 74 E> */ B(LoadIC), R(1), U8(0), U8(7),
+ /* 71 E> */ B(Star), R(0),
+ /* 83 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 88 E> */ B(LoadIC), R(1), U8(0), U8(9),
+ /* 85 E> */ B(Star), R(0),
+ /* 97 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 102 E> */ B(LoadIC), R(1), U8(0), U8(11),
+ /* 99 E> */ B(Star), R(0),
+ /* 111 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 116 E> */ B(LoadIC), R(1), U8(0), U8(13),
+ /* 113 E> */ B(Star), R(0),
+ /* 125 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 130 E> */ B(LoadIC), R(1), U8(0), U8(15),
+ /* 127 E> */ B(Star), R(0),
+ /* 139 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 144 E> */ B(LoadIC), R(1), U8(0), U8(17),
+ /* 141 E> */ B(Star), R(0),
+ /* 153 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 158 E> */ B(LoadIC), R(1), U8(0), U8(19),
+ /* 155 E> */ B(Star), R(0),
+ /* 167 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 172 E> */ B(LoadIC), R(1), U8(0), U8(21),
+ /* 169 E> */ B(Star), R(0),
+ /* 181 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 186 E> */ B(LoadIC), R(1), U8(0), U8(23),
+ /* 183 E> */ B(Star), R(0),
+ /* 195 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 200 E> */ B(LoadIC), R(1), U8(0), U8(25),
+ /* 197 E> */ B(Star), R(0),
+ /* 209 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 214 E> */ B(LoadIC), R(1), U8(0), U8(27),
+ /* 211 E> */ B(Star), R(0),
+ /* 223 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 228 E> */ B(LoadIC), R(1), U8(0), U8(29),
+ /* 225 E> */ B(Star), R(0),
+ /* 237 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 242 E> */ B(LoadIC), R(1), U8(0), U8(31),
+ /* 239 E> */ B(Star), R(0),
+ /* 251 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 256 E> */ B(LoadIC), R(1), U8(0), U8(33),
+ /* 253 E> */ B(Star), R(0),
+ /* 265 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 270 E> */ B(LoadIC), R(1), U8(0), U8(35),
+ /* 267 E> */ B(Star), R(0),
+ /* 279 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 284 E> */ B(LoadIC), R(1), U8(0), U8(37),
+ /* 281 E> */ B(Star), R(0),
+ /* 293 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 298 E> */ B(LoadIC), R(1), U8(0), U8(39),
+ /* 295 E> */ B(Star), R(0),
+ /* 307 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 312 E> */ B(LoadIC), R(1), U8(0), U8(41),
+ /* 309 E> */ B(Star), R(0),
+ /* 321 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 326 E> */ B(LoadIC), R(1), U8(0), U8(43),
+ /* 323 E> */ B(Star), R(0),
+ /* 335 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 340 E> */ B(LoadIC), R(1), U8(0), U8(45),
+ /* 337 E> */ B(Star), R(0),
+ /* 349 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 354 E> */ B(LoadIC), R(1), U8(0), U8(47),
+ /* 351 E> */ B(Star), R(0),
+ /* 363 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 368 E> */ B(LoadIC), R(1), U8(0), U8(49),
+ /* 365 E> */ B(Star), R(0),
+ /* 377 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 382 E> */ B(LoadIC), R(1), U8(0), U8(51),
+ /* 379 E> */ B(Star), R(0),
+ /* 391 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 396 E> */ B(LoadIC), R(1), U8(0), U8(53),
+ /* 393 E> */ B(Star), R(0),
+ /* 405 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 410 E> */ B(LoadIC), R(1), U8(0), U8(55),
+ /* 407 E> */ B(Star), R(0),
+ /* 419 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 424 E> */ B(LoadIC), R(1), U8(0), U8(57),
+ /* 421 E> */ B(Star), R(0),
+ /* 433 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 438 E> */ B(LoadIC), R(1), U8(0), U8(59),
+ /* 435 E> */ B(Star), R(0),
+ /* 447 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 452 E> */ B(LoadIC), R(1), U8(0), U8(61),
+ /* 449 E> */ B(Star), R(0),
+ /* 461 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 466 E> */ B(LoadIC), R(1), U8(0), U8(63),
+ /* 463 E> */ B(Star), R(0),
+ /* 475 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 480 E> */ B(LoadIC), R(1), U8(0), U8(65),
+ /* 477 E> */ B(Star), R(0),
+ /* 489 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 494 E> */ B(LoadIC), R(1), U8(0), U8(67),
+ /* 491 E> */ B(Star), R(0),
+ /* 503 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 508 E> */ B(LoadIC), R(1), U8(0), U8(69),
+ /* 505 E> */ B(Star), R(0),
+ /* 517 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 522 E> */ B(LoadIC), R(1), U8(0), U8(71),
+ /* 519 E> */ B(Star), R(0),
+ /* 531 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 536 E> */ B(LoadIC), R(1), U8(0), U8(73),
+ /* 533 E> */ B(Star), R(0),
+ /* 545 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 550 E> */ B(LoadIC), R(1), U8(0), U8(75),
+ /* 547 E> */ B(Star), R(0),
+ /* 559 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 564 E> */ B(LoadIC), R(1), U8(0), U8(77),
+ /* 561 E> */ B(Star), R(0),
+ /* 573 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 578 E> */ B(LoadIC), R(1), U8(0), U8(79),
+ /* 575 E> */ B(Star), R(0),
+ /* 587 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 592 E> */ B(LoadIC), R(1), U8(0), U8(81),
+ /* 589 E> */ B(Star), R(0),
+ /* 601 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 606 E> */ B(LoadIC), R(1), U8(0), U8(83),
+ /* 603 E> */ B(Star), R(0),
+ /* 615 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 620 E> */ B(LoadIC), R(1), U8(0), U8(85),
+ /* 617 E> */ B(Star), R(0),
+ /* 629 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 634 E> */ B(LoadIC), R(1), U8(0), U8(87),
+ /* 631 E> */ B(Star), R(0),
+ /* 643 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 648 E> */ B(LoadIC), R(1), U8(0), U8(89),
+ /* 645 E> */ B(Star), R(0),
+ /* 657 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 662 E> */ B(LoadIC), R(1), U8(0), U8(91),
+ /* 659 E> */ B(Star), R(0),
+ /* 671 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 676 E> */ B(LoadIC), R(1), U8(0), U8(93),
+ /* 673 E> */ B(Star), R(0),
+ /* 685 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 690 E> */ B(LoadIC), R(1), U8(0), U8(95),
+ /* 687 E> */ B(Star), R(0),
+ /* 699 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 704 E> */ B(LoadIC), R(1), U8(0), U8(97),
+ /* 701 E> */ B(Star), R(0),
+ /* 713 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 718 E> */ B(LoadIC), R(1), U8(0), U8(99),
+ /* 715 E> */ B(Star), R(0),
+ /* 727 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 732 E> */ B(LoadIC), R(1), U8(0), U8(101),
+ /* 729 E> */ B(Star), R(0),
+ /* 741 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 746 E> */ B(LoadIC), R(1), U8(0), U8(103),
+ /* 743 E> */ B(Star), R(0),
+ /* 755 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 760 E> */ B(LoadIC), R(1), U8(0), U8(105),
+ /* 757 E> */ B(Star), R(0),
+ /* 769 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 774 E> */ B(LoadIC), R(1), U8(0), U8(107),
+ /* 771 E> */ B(Star), R(0),
+ /* 783 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 788 E> */ B(LoadIC), R(1), U8(0), U8(109),
+ /* 785 E> */ B(Star), R(0),
+ /* 797 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 802 E> */ B(LoadIC), R(1), U8(0), U8(111),
+ /* 799 E> */ B(Star), R(0),
+ /* 811 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 816 E> */ B(LoadIC), R(1), U8(0), U8(113),
+ /* 813 E> */ B(Star), R(0),
+ /* 825 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 830 E> */ B(LoadIC), R(1), U8(0), U8(115),
+ /* 827 E> */ B(Star), R(0),
+ /* 839 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 844 E> */ B(LoadIC), R(1), U8(0), U8(117),
+ /* 841 E> */ B(Star), R(0),
+ /* 853 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 858 E> */ B(LoadIC), R(1), U8(0), U8(119),
+ /* 855 E> */ B(Star), R(0),
+ /* 867 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 872 E> */ B(LoadIC), R(1), U8(0), U8(121),
+ /* 869 E> */ B(Star), R(0),
+ /* 881 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 886 E> */ B(LoadIC), R(1), U8(0), U8(123),
+ /* 883 E> */ B(Star), R(0),
+ /* 895 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 900 E> */ B(LoadIC), R(1), U8(0), U8(125),
+ /* 897 E> */ B(Star), R(0),
+ /* 909 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 914 E> */ B(LoadIC), R(1), U8(0), U8(127),
+ /* 911 E> */ B(Star), R(0),
+ /* 923 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 928 E> */ B(LoadIC), R(1), U8(0), U8(129),
+ /* 925 E> */ B(Star), R(0),
+ /* 937 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 942 E> */ B(LoadIC), R(1), U8(0), U8(131),
+ /* 939 E> */ B(Star), R(0),
+ /* 951 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 956 E> */ B(LoadIC), R(1), U8(0), U8(133),
+ /* 953 E> */ B(Star), R(0),
+ /* 965 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 970 E> */ B(LoadIC), R(1), U8(0), U8(135),
+ /* 967 E> */ B(Star), R(0),
+ /* 979 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 984 E> */ B(LoadIC), R(1), U8(0), U8(137),
+ /* 981 E> */ B(Star), R(0),
+ /* 993 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 998 E> */ B(LoadIC), R(1), U8(0), U8(139),
+ /* 995 E> */ B(Star), R(0),
+ /* 1007 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1012 E> */ B(LoadIC), R(1), U8(0), U8(141),
+ /* 1009 E> */ B(Star), R(0),
+ /* 1021 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1026 E> */ B(LoadIC), R(1), U8(0), U8(143),
+ /* 1023 E> */ B(Star), R(0),
+ /* 1035 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1040 E> */ B(LoadIC), R(1), U8(0), U8(145),
+ /* 1037 E> */ B(Star), R(0),
+ /* 1049 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1054 E> */ B(LoadIC), R(1), U8(0), U8(147),
+ /* 1051 E> */ B(Star), R(0),
+ /* 1063 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1068 E> */ B(LoadIC), R(1), U8(0), U8(149),
+ /* 1065 E> */ B(Star), R(0),
+ /* 1077 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1082 E> */ B(LoadIC), R(1), U8(0), U8(151),
+ /* 1079 E> */ B(Star), R(0),
+ /* 1091 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1096 E> */ B(LoadIC), R(1), U8(0), U8(153),
+ /* 1093 E> */ B(Star), R(0),
+ /* 1105 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1110 E> */ B(LoadIC), R(1), U8(0), U8(155),
+ /* 1107 E> */ B(Star), R(0),
+ /* 1119 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1124 E> */ B(LoadIC), R(1), U8(0), U8(157),
+ /* 1121 E> */ B(Star), R(0),
+ /* 1133 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1138 E> */ B(LoadIC), R(1), U8(0), U8(159),
+ /* 1135 E> */ B(Star), R(0),
+ /* 1147 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1152 E> */ B(LoadIC), R(1), U8(0), U8(161),
+ /* 1149 E> */ B(Star), R(0),
+ /* 1161 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1166 E> */ B(LoadIC), R(1), U8(0), U8(163),
+ /* 1163 E> */ B(Star), R(0),
+ /* 1175 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1180 E> */ B(LoadIC), R(1), U8(0), U8(165),
+ /* 1177 E> */ B(Star), R(0),
+ /* 1189 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1194 E> */ B(LoadIC), R(1), U8(0), U8(167),
+ /* 1191 E> */ B(Star), R(0),
+ /* 1203 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1208 E> */ B(LoadIC), R(1), U8(0), U8(169),
+ /* 1205 E> */ B(Star), R(0),
+ /* 1217 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1222 E> */ B(LoadIC), R(1), U8(0), U8(171),
+ /* 1219 E> */ B(Star), R(0),
+ /* 1231 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1236 E> */ B(LoadIC), R(1), U8(0), U8(173),
+ /* 1233 E> */ B(Star), R(0),
+ /* 1245 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1250 E> */ B(LoadIC), R(1), U8(0), U8(175),
+ /* 1247 E> */ B(Star), R(0),
+ /* 1259 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1264 E> */ B(LoadIC), R(1), U8(0), U8(177),
+ /* 1261 E> */ B(Star), R(0),
+ /* 1273 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1278 E> */ B(LoadIC), R(1), U8(0), U8(179),
+ /* 1275 E> */ B(Star), R(0),
+ /* 1287 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1292 E> */ B(LoadIC), R(1), U8(0), U8(181),
+ /* 1289 E> */ B(Star), R(0),
+ /* 1301 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1306 E> */ B(LoadIC), R(1), U8(0), U8(183),
+ /* 1303 E> */ B(Star), R(0),
+ /* 1315 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1320 E> */ B(LoadIC), R(1), U8(0), U8(185),
+ /* 1317 E> */ B(Star), R(0),
+ /* 1329 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1334 E> */ B(LoadIC), R(1), U8(0), U8(187),
+ /* 1331 E> */ B(Star), R(0),
+ /* 1343 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1348 E> */ B(LoadIC), R(1), U8(0), U8(189),
+ /* 1345 E> */ B(Star), R(0),
+ /* 1357 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1362 E> */ B(LoadIC), R(1), U8(0), U8(191),
+ /* 1359 E> */ B(Star), R(0),
+ /* 1371 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1376 E> */ B(LoadIC), R(1), U8(0), U8(193),
+ /* 1373 E> */ B(Star), R(0),
+ /* 1385 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1390 E> */ B(LoadIC), R(1), U8(0), U8(195),
+ /* 1387 E> */ B(Star), R(0),
+ /* 1399 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1404 E> */ B(LoadIC), R(1), U8(0), U8(197),
+ /* 1401 E> */ B(Star), R(0),
+ /* 1413 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1418 E> */ B(LoadIC), R(1), U8(0), U8(199),
+ /* 1415 E> */ B(Star), R(0),
+ /* 1427 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1432 E> */ B(LoadIC), R(1), U8(0), U8(201),
+ /* 1429 E> */ B(Star), R(0),
+ /* 1441 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1446 E> */ B(LoadIC), R(1), U8(0), U8(203),
+ /* 1443 E> */ B(Star), R(0),
+ /* 1455 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1460 E> */ B(LoadIC), R(1), U8(0), U8(205),
+ /* 1457 E> */ B(Star), R(0),
+ /* 1469 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1474 E> */ B(LoadIC), R(1), U8(0), U8(207),
+ /* 1471 E> */ B(Star), R(0),
+ /* 1483 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1488 E> */ B(LoadIC), R(1), U8(0), U8(209),
+ /* 1485 E> */ B(Star), R(0),
+ /* 1497 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1502 E> */ B(LoadIC), R(1), U8(0), U8(211),
+ /* 1499 E> */ B(Star), R(0),
+ /* 1511 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1516 E> */ B(LoadIC), R(1), U8(0), U8(213),
+ /* 1513 E> */ B(Star), R(0),
+ /* 1525 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1530 E> */ B(LoadIC), R(1), U8(0), U8(215),
+ /* 1527 E> */ B(Star), R(0),
+ /* 1539 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1544 E> */ B(LoadIC), R(1), U8(0), U8(217),
+ /* 1541 E> */ B(Star), R(0),
+ /* 1553 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1558 E> */ B(LoadIC), R(1), U8(0), U8(219),
+ /* 1555 E> */ B(Star), R(0),
+ /* 1567 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1572 E> */ B(LoadIC), R(1), U8(0), U8(221),
+ /* 1569 E> */ B(Star), R(0),
+ /* 1581 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1586 E> */ B(LoadIC), R(1), U8(0), U8(223),
+ /* 1583 E> */ B(Star), R(0),
+ /* 1595 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1600 E> */ B(LoadIC), R(1), U8(0), U8(225),
+ /* 1597 E> */ B(Star), R(0),
+ /* 1609 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1614 E> */ B(LoadIC), R(1), U8(0), U8(227),
+ /* 1611 E> */ B(Star), R(0),
+ /* 1623 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1628 E> */ B(LoadIC), R(1), U8(0), U8(229),
+ /* 1625 E> */ B(Star), R(0),
+ /* 1637 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1642 E> */ B(LoadIC), R(1), U8(0), U8(231),
+ /* 1639 E> */ B(Star), R(0),
+ /* 1651 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1656 E> */ B(LoadIC), R(1), U8(0), U8(233),
+ /* 1653 E> */ B(Star), R(0),
+ /* 1665 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1670 E> */ B(LoadIC), R(1), U8(0), U8(235),
+ /* 1667 E> */ B(Star), R(0),
+ /* 1679 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1684 E> */ B(LoadIC), R(1), U8(0), U8(237),
+ /* 1681 E> */ B(Star), R(0),
+ /* 1693 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1698 E> */ B(LoadIC), R(1), U8(0), U8(239),
+ /* 1695 E> */ B(Star), R(0),
+ /* 1707 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1712 E> */ B(LoadIC), R(1), U8(0), U8(241),
+ /* 1709 E> */ B(Star), R(0),
+ /* 1721 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1726 E> */ B(LoadIC), R(1), U8(0), U8(243),
+ /* 1723 E> */ B(Star), R(0),
+ /* 1735 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1740 E> */ B(LoadIC), R(1), U8(0), U8(245),
+ /* 1737 E> */ B(Star), R(0),
+ /* 1749 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1754 E> */ B(LoadIC), R(1), U8(0), U8(247),
+ /* 1751 E> */ B(Star), R(0),
+ /* 1763 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1768 E> */ B(LoadIC), R(1), U8(0), U8(249),
+ /* 1765 E> */ B(Star), R(0),
+ /* 1777 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1782 E> */ B(LoadIC), R(1), U8(0), U8(251),
+ /* 1779 E> */ B(Star), R(0),
+ /* 1791 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1796 E> */ B(LoadIC), R(1), U8(0), U8(253),
+ /* 1793 E> */ B(Star), R(0),
+ /* 1805 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1810 E> */ B(LoadIC), R(1), U8(0), U8(255),
+ /* 1807 E> */ B(Star), R(0),
+ /* 1819 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1827 E> */ B(Wide), B(LoadIC), R16(1), U16(0), U16(257),
+ /* 1834 S> */ B(Return),
]
constant pool: [
"name",
@@ -922,652 +922,652 @@
parameter count: 3
bytecode array length: 1422
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(1),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(3),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(5),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(7),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(9),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(11),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(13),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(15),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(17),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(19),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(21),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(23),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(25),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(27),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(29),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(31),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(33),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(35),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(37),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(39),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(41),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(43),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(45),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(47),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(49),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(51),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(53),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(55),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(57),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(59),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(61),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(63),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(65),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(67),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(69),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(71),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(73),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(75),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(77),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(79),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(81),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(83),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(85),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(87),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(89),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(91),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(93),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(95),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(97),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(99),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(101),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(103),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(105),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(107),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(109),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(111),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(113),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(115),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(117),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(119),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(121),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(123),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(125),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(127),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(129),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(131),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(133),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(135),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(137),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(139),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(141),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(143),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(145),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(147),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(149),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(151),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(153),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(155),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(157),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(159),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(161),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(163),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(165),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(167),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(169),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(171),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(173),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(175),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(177),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(179),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(181),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(183),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(185),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(187),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(189),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(191),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(193),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(195),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(197),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(199),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(201),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(203),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(205),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(207),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(209),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(211),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(213),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(215),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(217),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(219),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(221),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(223),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(225),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(227),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(229),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(231),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(233),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(235),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(237),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(239),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(241),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(243),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(245),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(247),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(249),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(251),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(253),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(KeyedLoadIC), R(1), U8(255),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(Ldar), R(arg1),
- B(Wide), B(KeyedLoadIC), R16(1), U16(257),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 30 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 35 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(1),
+ /* 32 E> */ B(Star), R(0),
+ /* 42 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 47 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(3),
+ /* 44 E> */ B(Star), R(0),
+ /* 54 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 59 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(5),
+ /* 56 E> */ B(Star), R(0),
+ /* 66 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 71 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(7),
+ /* 68 E> */ B(Star), R(0),
+ /* 78 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 83 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(9),
+ /* 80 E> */ B(Star), R(0),
+ /* 90 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 95 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(11),
+ /* 92 E> */ B(Star), R(0),
+ /* 102 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 107 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(13),
+ /* 104 E> */ B(Star), R(0),
+ /* 114 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 119 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(15),
+ /* 116 E> */ B(Star), R(0),
+ /* 126 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 131 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(17),
+ /* 128 E> */ B(Star), R(0),
+ /* 138 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 143 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(19),
+ /* 140 E> */ B(Star), R(0),
+ /* 150 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 155 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(21),
+ /* 152 E> */ B(Star), R(0),
+ /* 162 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 167 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(23),
+ /* 164 E> */ B(Star), R(0),
+ /* 174 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 179 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(25),
+ /* 176 E> */ B(Star), R(0),
+ /* 186 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 191 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(27),
+ /* 188 E> */ B(Star), R(0),
+ /* 198 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 203 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(29),
+ /* 200 E> */ B(Star), R(0),
+ /* 210 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 215 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(31),
+ /* 212 E> */ B(Star), R(0),
+ /* 222 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 227 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(33),
+ /* 224 E> */ B(Star), R(0),
+ /* 234 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 239 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(35),
+ /* 236 E> */ B(Star), R(0),
+ /* 246 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 251 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(37),
+ /* 248 E> */ B(Star), R(0),
+ /* 258 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 263 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(39),
+ /* 260 E> */ B(Star), R(0),
+ /* 270 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 275 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(41),
+ /* 272 E> */ B(Star), R(0),
+ /* 282 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 287 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(43),
+ /* 284 E> */ B(Star), R(0),
+ /* 294 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 299 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(45),
+ /* 296 E> */ B(Star), R(0),
+ /* 306 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 311 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(47),
+ /* 308 E> */ B(Star), R(0),
+ /* 318 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 323 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(49),
+ /* 320 E> */ B(Star), R(0),
+ /* 330 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 335 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(51),
+ /* 332 E> */ B(Star), R(0),
+ /* 342 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 347 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(53),
+ /* 344 E> */ B(Star), R(0),
+ /* 354 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 359 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(55),
+ /* 356 E> */ B(Star), R(0),
+ /* 366 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 371 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(57),
+ /* 368 E> */ B(Star), R(0),
+ /* 378 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 383 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(59),
+ /* 380 E> */ B(Star), R(0),
+ /* 390 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 395 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(61),
+ /* 392 E> */ B(Star), R(0),
+ /* 402 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 407 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(63),
+ /* 404 E> */ B(Star), R(0),
+ /* 414 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 419 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(65),
+ /* 416 E> */ B(Star), R(0),
+ /* 426 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 431 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(67),
+ /* 428 E> */ B(Star), R(0),
+ /* 438 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 443 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(69),
+ /* 440 E> */ B(Star), R(0),
+ /* 450 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 455 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(71),
+ /* 452 E> */ B(Star), R(0),
+ /* 462 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 467 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(73),
+ /* 464 E> */ B(Star), R(0),
+ /* 474 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 479 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(75),
+ /* 476 E> */ B(Star), R(0),
+ /* 486 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 491 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(77),
+ /* 488 E> */ B(Star), R(0),
+ /* 498 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 503 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(79),
+ /* 500 E> */ B(Star), R(0),
+ /* 510 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 515 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(81),
+ /* 512 E> */ B(Star), R(0),
+ /* 522 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 527 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(83),
+ /* 524 E> */ B(Star), R(0),
+ /* 534 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 539 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(85),
+ /* 536 E> */ B(Star), R(0),
+ /* 546 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 551 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(87),
+ /* 548 E> */ B(Star), R(0),
+ /* 558 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 563 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(89),
+ /* 560 E> */ B(Star), R(0),
+ /* 570 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 575 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(91),
+ /* 572 E> */ B(Star), R(0),
+ /* 582 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 587 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(93),
+ /* 584 E> */ B(Star), R(0),
+ /* 594 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 599 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(95),
+ /* 596 E> */ B(Star), R(0),
+ /* 606 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 611 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(97),
+ /* 608 E> */ B(Star), R(0),
+ /* 618 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 623 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(99),
+ /* 620 E> */ B(Star), R(0),
+ /* 630 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 635 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(101),
+ /* 632 E> */ B(Star), R(0),
+ /* 642 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 647 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(103),
+ /* 644 E> */ B(Star), R(0),
+ /* 654 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 659 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(105),
+ /* 656 E> */ B(Star), R(0),
+ /* 666 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 671 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(107),
+ /* 668 E> */ B(Star), R(0),
+ /* 678 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 683 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(109),
+ /* 680 E> */ B(Star), R(0),
+ /* 690 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 695 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(111),
+ /* 692 E> */ B(Star), R(0),
+ /* 702 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 707 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(113),
+ /* 704 E> */ B(Star), R(0),
+ /* 714 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 719 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(115),
+ /* 716 E> */ B(Star), R(0),
+ /* 726 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 731 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(117),
+ /* 728 E> */ B(Star), R(0),
+ /* 738 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 743 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(119),
+ /* 740 E> */ B(Star), R(0),
+ /* 750 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 755 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(121),
+ /* 752 E> */ B(Star), R(0),
+ /* 762 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 767 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(123),
+ /* 764 E> */ B(Star), R(0),
+ /* 774 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 779 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(125),
+ /* 776 E> */ B(Star), R(0),
+ /* 786 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 791 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(127),
+ /* 788 E> */ B(Star), R(0),
+ /* 798 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 803 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(129),
+ /* 800 E> */ B(Star), R(0),
+ /* 810 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 815 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(131),
+ /* 812 E> */ B(Star), R(0),
+ /* 822 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 827 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(133),
+ /* 824 E> */ B(Star), R(0),
+ /* 834 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 839 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(135),
+ /* 836 E> */ B(Star), R(0),
+ /* 846 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 851 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(137),
+ /* 848 E> */ B(Star), R(0),
+ /* 858 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 863 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(139),
+ /* 860 E> */ B(Star), R(0),
+ /* 870 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 875 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(141),
+ /* 872 E> */ B(Star), R(0),
+ /* 882 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 887 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(143),
+ /* 884 E> */ B(Star), R(0),
+ /* 894 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 899 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(145),
+ /* 896 E> */ B(Star), R(0),
+ /* 906 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 911 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(147),
+ /* 908 E> */ B(Star), R(0),
+ /* 918 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 923 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(149),
+ /* 920 E> */ B(Star), R(0),
+ /* 930 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 935 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(151),
+ /* 932 E> */ B(Star), R(0),
+ /* 942 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 947 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(153),
+ /* 944 E> */ B(Star), R(0),
+ /* 954 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 959 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(155),
+ /* 956 E> */ B(Star), R(0),
+ /* 966 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 971 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(157),
+ /* 968 E> */ B(Star), R(0),
+ /* 978 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 983 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(159),
+ /* 980 E> */ B(Star), R(0),
+ /* 990 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 995 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(161),
+ /* 992 E> */ B(Star), R(0),
+ /* 1002 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1007 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(163),
+ /* 1004 E> */ B(Star), R(0),
+ /* 1014 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1019 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(165),
+ /* 1016 E> */ B(Star), R(0),
+ /* 1026 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1031 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(167),
+ /* 1028 E> */ B(Star), R(0),
+ /* 1038 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1043 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(169),
+ /* 1040 E> */ B(Star), R(0),
+ /* 1050 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1055 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(171),
+ /* 1052 E> */ B(Star), R(0),
+ /* 1062 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1067 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(173),
+ /* 1064 E> */ B(Star), R(0),
+ /* 1074 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1079 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(175),
+ /* 1076 E> */ B(Star), R(0),
+ /* 1086 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1091 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(177),
+ /* 1088 E> */ B(Star), R(0),
+ /* 1098 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1103 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(179),
+ /* 1100 E> */ B(Star), R(0),
+ /* 1110 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1115 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(181),
+ /* 1112 E> */ B(Star), R(0),
+ /* 1122 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1127 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(183),
+ /* 1124 E> */ B(Star), R(0),
+ /* 1134 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1139 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(185),
+ /* 1136 E> */ B(Star), R(0),
+ /* 1146 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1151 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(187),
+ /* 1148 E> */ B(Star), R(0),
+ /* 1158 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1163 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(189),
+ /* 1160 E> */ B(Star), R(0),
+ /* 1170 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1175 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(191),
+ /* 1172 E> */ B(Star), R(0),
+ /* 1182 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1187 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(193),
+ /* 1184 E> */ B(Star), R(0),
+ /* 1194 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1199 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(195),
+ /* 1196 E> */ B(Star), R(0),
+ /* 1206 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1211 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(197),
+ /* 1208 E> */ B(Star), R(0),
+ /* 1218 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1223 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(199),
+ /* 1220 E> */ B(Star), R(0),
+ /* 1230 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1235 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(201),
+ /* 1232 E> */ B(Star), R(0),
+ /* 1242 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1247 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(203),
+ /* 1244 E> */ B(Star), R(0),
+ /* 1254 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1259 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(205),
+ /* 1256 E> */ B(Star), R(0),
+ /* 1266 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1271 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(207),
+ /* 1268 E> */ B(Star), R(0),
+ /* 1278 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1283 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(209),
+ /* 1280 E> */ B(Star), R(0),
+ /* 1290 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1295 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(211),
+ /* 1292 E> */ B(Star), R(0),
+ /* 1302 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1307 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(213),
+ /* 1304 E> */ B(Star), R(0),
+ /* 1314 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1319 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(215),
+ /* 1316 E> */ B(Star), R(0),
+ /* 1326 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1331 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(217),
+ /* 1328 E> */ B(Star), R(0),
+ /* 1338 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1343 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(219),
+ /* 1340 E> */ B(Star), R(0),
+ /* 1350 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1355 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(221),
+ /* 1352 E> */ B(Star), R(0),
+ /* 1362 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1367 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(223),
+ /* 1364 E> */ B(Star), R(0),
+ /* 1374 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1379 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(225),
+ /* 1376 E> */ B(Star), R(0),
+ /* 1386 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1391 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(227),
+ /* 1388 E> */ B(Star), R(0),
+ /* 1398 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1403 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(229),
+ /* 1400 E> */ B(Star), R(0),
+ /* 1410 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1415 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(231),
+ /* 1412 E> */ B(Star), R(0),
+ /* 1422 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1427 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(233),
+ /* 1424 E> */ B(Star), R(0),
+ /* 1434 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1439 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(235),
+ /* 1436 E> */ B(Star), R(0),
+ /* 1446 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1451 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(237),
+ /* 1448 E> */ B(Star), R(0),
+ /* 1458 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1463 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(239),
+ /* 1460 E> */ B(Star), R(0),
+ /* 1470 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1475 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(241),
+ /* 1472 E> */ B(Star), R(0),
+ /* 1482 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1487 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(243),
+ /* 1484 E> */ B(Star), R(0),
+ /* 1494 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1499 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(245),
+ /* 1496 E> */ B(Star), R(0),
+ /* 1506 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1511 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(247),
+ /* 1508 E> */ B(Star), R(0),
+ /* 1518 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1523 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(249),
+ /* 1520 E> */ B(Star), R(0),
+ /* 1530 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1535 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(251),
+ /* 1532 E> */ B(Star), R(0),
+ /* 1542 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1547 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(253),
+ /* 1544 E> */ B(Star), R(0),
+ /* 1554 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1559 E> */ B(Ldar), R(arg1),
+ B(KeyedLoadIC), R(1), U8(255),
+ /* 1556 E> */ B(Star), R(0),
+ /* 1566 S> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 1574 E> */ B(Ldar), R(arg1),
+ B(Wide), B(KeyedLoadIC), R16(1), U16(257),
+ /* 1579 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/PropertyStores.golden b/test/cctest/interpreter/bytecode_expectations/PropertyStores.golden
index 9e67a90..340aa43 100644
--- a/test/cctest/interpreter/bytecode_expectations/PropertyStores.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PropertyStores.golden
@@ -17,13 +17,13 @@
parameter count: 2
bytecode array length: 13
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaConstant), U8(0),
- B(StoreICSloppy), R(0), U8(1), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 16 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaConstant), U8(0),
+ /* 23 E> */ B(StoreICSloppy), R(0), U8(1), U8(1),
+ B(LdaUndefined),
+ /* 32 S> */ B(Return),
]
constant pool: [
"val",
@@ -41,13 +41,13 @@
parameter count: 2
bytecode array length: 13
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaConstant), U8(0),
- B(StoreICSloppy), R(0), U8(1), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 16 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaConstant), U8(0),
+ /* 25 E> */ B(StoreICSloppy), R(0), U8(1), U8(1),
+ B(LdaUndefined),
+ /* 34 S> */ B(Return),
]
constant pool: [
"val",
@@ -65,15 +65,15 @@
parameter count: 2
bytecode array length: 17
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(100),
- B(Star), R(1),
- B(LdaConstant), U8(0),
- B(KeyedStoreICSloppy), R(0), R(1), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 16 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(100),
+ B(Star), R(1),
+ B(LdaConstant), U8(0),
+ /* 23 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(1),
+ B(LdaUndefined),
+ /* 32 S> */ B(Return),
]
constant pool: [
"val",
@@ -90,15 +90,15 @@
parameter count: 3
bytecode array length: 17
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaConstant), U8(0),
- B(KeyedStoreICSloppy), R(0), R(1), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 19 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 21 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaConstant), U8(0),
+ /* 24 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(1),
+ B(LdaUndefined),
+ /* 33 S> */ B(Return),
]
constant pool: [
"val",
@@ -115,16 +115,16 @@
parameter count: 2
bytecode array length: 20
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg0),
- B(Star), R(1),
- B(LdaSmi), U8(-124),
- B(KeyedLoadIC), R(1), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(3),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 16 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 25 E> */ B(Ldar), R(arg0),
+ B(Star), R(1),
+ /* 26 E> */ B(LdaSmi), U8(-124),
+ B(KeyedLoadIC), R(1), U8(1),
+ /* 23 E> */ B(StoreICSloppy), R(0), U8(0), U8(3),
+ B(LdaUndefined),
+ /* 34 S> */ B(Return),
]
constant pool: [
"name",
@@ -141,13 +141,13 @@
parameter count: 2
bytecode array length: 13
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaConstant), U8(0),
- B(StoreICStrict), R(0), U8(1), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 30 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaConstant), U8(0),
+ /* 37 E> */ B(StoreICStrict), R(0), U8(1), U8(1),
+ B(LdaUndefined),
+ /* 46 S> */ B(Return),
]
constant pool: [
"val",
@@ -165,15 +165,15 @@
parameter count: 3
bytecode array length: 17
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaConstant), U8(0),
- B(KeyedStoreICStrict), R(0), R(1), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 33 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 35 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaConstant), U8(0),
+ /* 38 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(1),
+ B(LdaUndefined),
+ /* 47 S> */ B(Return),
]
constant pool: [
"val",
@@ -320,525 +320,525 @@
parameter count: 2
bytecode array length: 1297
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(1),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(3),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(5),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(7),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(9),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(11),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(13),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(15),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(17),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(19),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(21),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(23),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(25),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(27),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(29),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(31),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(33),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(35),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(37),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(39),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(41),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(43),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(45),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(47),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(49),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(51),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(53),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(55),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(57),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(59),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(61),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(63),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(65),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(67),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(69),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(71),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(73),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(75),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(77),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(79),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(81),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(83),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(85),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(87),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(89),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(91),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(93),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(95),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(97),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(99),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(101),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(103),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(105),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(107),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(109),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(111),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(113),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(115),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(117),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(119),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(121),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(123),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(125),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(127),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(129),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(131),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(133),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(135),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(137),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(139),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(141),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(143),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(145),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(147),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(149),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(151),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(153),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(155),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(157),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(159),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(161),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(163),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(165),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(167),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(169),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(171),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(173),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(175),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(177),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(179),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(181),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(183),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(185),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(187),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(189),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(191),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(193),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(195),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(197),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(199),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(201),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(203),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(205),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(207),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(209),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(211),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(213),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(215),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(217),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(219),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(221),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(223),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(225),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(227),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(229),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(231),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(233),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(235),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(237),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(239),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(241),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(243),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(245),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(247),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(249),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(251),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(253),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICSloppy), R(0), U8(0), U8(255),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(2),
- B(Wide), B(StoreICSloppy), R16(0), U16(0), U16(257),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 18 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 25 E> */ B(StoreICSloppy), R(0), U8(0), U8(1),
+ /* 32 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 39 E> */ B(StoreICSloppy), R(0), U8(0), U8(3),
+ /* 46 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 53 E> */ B(StoreICSloppy), R(0), U8(0), U8(5),
+ /* 60 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 67 E> */ B(StoreICSloppy), R(0), U8(0), U8(7),
+ /* 74 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 81 E> */ B(StoreICSloppy), R(0), U8(0), U8(9),
+ /* 88 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 95 E> */ B(StoreICSloppy), R(0), U8(0), U8(11),
+ /* 102 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 109 E> */ B(StoreICSloppy), R(0), U8(0), U8(13),
+ /* 116 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 123 E> */ B(StoreICSloppy), R(0), U8(0), U8(15),
+ /* 130 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 137 E> */ B(StoreICSloppy), R(0), U8(0), U8(17),
+ /* 144 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 151 E> */ B(StoreICSloppy), R(0), U8(0), U8(19),
+ /* 158 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 165 E> */ B(StoreICSloppy), R(0), U8(0), U8(21),
+ /* 172 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 179 E> */ B(StoreICSloppy), R(0), U8(0), U8(23),
+ /* 186 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 193 E> */ B(StoreICSloppy), R(0), U8(0), U8(25),
+ /* 200 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 207 E> */ B(StoreICSloppy), R(0), U8(0), U8(27),
+ /* 214 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 221 E> */ B(StoreICSloppy), R(0), U8(0), U8(29),
+ /* 228 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 235 E> */ B(StoreICSloppy), R(0), U8(0), U8(31),
+ /* 242 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 249 E> */ B(StoreICSloppy), R(0), U8(0), U8(33),
+ /* 256 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 263 E> */ B(StoreICSloppy), R(0), U8(0), U8(35),
+ /* 270 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 277 E> */ B(StoreICSloppy), R(0), U8(0), U8(37),
+ /* 284 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 291 E> */ B(StoreICSloppy), R(0), U8(0), U8(39),
+ /* 298 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 305 E> */ B(StoreICSloppy), R(0), U8(0), U8(41),
+ /* 312 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 319 E> */ B(StoreICSloppy), R(0), U8(0), U8(43),
+ /* 326 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 333 E> */ B(StoreICSloppy), R(0), U8(0), U8(45),
+ /* 340 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 347 E> */ B(StoreICSloppy), R(0), U8(0), U8(47),
+ /* 354 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 361 E> */ B(StoreICSloppy), R(0), U8(0), U8(49),
+ /* 368 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 375 E> */ B(StoreICSloppy), R(0), U8(0), U8(51),
+ /* 382 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 389 E> */ B(StoreICSloppy), R(0), U8(0), U8(53),
+ /* 396 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 403 E> */ B(StoreICSloppy), R(0), U8(0), U8(55),
+ /* 410 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 417 E> */ B(StoreICSloppy), R(0), U8(0), U8(57),
+ /* 424 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 431 E> */ B(StoreICSloppy), R(0), U8(0), U8(59),
+ /* 438 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 445 E> */ B(StoreICSloppy), R(0), U8(0), U8(61),
+ /* 452 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 459 E> */ B(StoreICSloppy), R(0), U8(0), U8(63),
+ /* 466 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 473 E> */ B(StoreICSloppy), R(0), U8(0), U8(65),
+ /* 480 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 487 E> */ B(StoreICSloppy), R(0), U8(0), U8(67),
+ /* 494 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 501 E> */ B(StoreICSloppy), R(0), U8(0), U8(69),
+ /* 508 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 515 E> */ B(StoreICSloppy), R(0), U8(0), U8(71),
+ /* 522 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 529 E> */ B(StoreICSloppy), R(0), U8(0), U8(73),
+ /* 536 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 543 E> */ B(StoreICSloppy), R(0), U8(0), U8(75),
+ /* 550 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 557 E> */ B(StoreICSloppy), R(0), U8(0), U8(77),
+ /* 564 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 571 E> */ B(StoreICSloppy), R(0), U8(0), U8(79),
+ /* 578 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 585 E> */ B(StoreICSloppy), R(0), U8(0), U8(81),
+ /* 592 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 599 E> */ B(StoreICSloppy), R(0), U8(0), U8(83),
+ /* 606 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 613 E> */ B(StoreICSloppy), R(0), U8(0), U8(85),
+ /* 620 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 627 E> */ B(StoreICSloppy), R(0), U8(0), U8(87),
+ /* 634 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 641 E> */ B(StoreICSloppy), R(0), U8(0), U8(89),
+ /* 648 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 655 E> */ B(StoreICSloppy), R(0), U8(0), U8(91),
+ /* 662 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 669 E> */ B(StoreICSloppy), R(0), U8(0), U8(93),
+ /* 676 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 683 E> */ B(StoreICSloppy), R(0), U8(0), U8(95),
+ /* 690 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 697 E> */ B(StoreICSloppy), R(0), U8(0), U8(97),
+ /* 704 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 711 E> */ B(StoreICSloppy), R(0), U8(0), U8(99),
+ /* 718 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 725 E> */ B(StoreICSloppy), R(0), U8(0), U8(101),
+ /* 732 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 739 E> */ B(StoreICSloppy), R(0), U8(0), U8(103),
+ /* 746 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 753 E> */ B(StoreICSloppy), R(0), U8(0), U8(105),
+ /* 760 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 767 E> */ B(StoreICSloppy), R(0), U8(0), U8(107),
+ /* 774 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 781 E> */ B(StoreICSloppy), R(0), U8(0), U8(109),
+ /* 788 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 795 E> */ B(StoreICSloppy), R(0), U8(0), U8(111),
+ /* 802 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 809 E> */ B(StoreICSloppy), R(0), U8(0), U8(113),
+ /* 816 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 823 E> */ B(StoreICSloppy), R(0), U8(0), U8(115),
+ /* 830 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 837 E> */ B(StoreICSloppy), R(0), U8(0), U8(117),
+ /* 844 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 851 E> */ B(StoreICSloppy), R(0), U8(0), U8(119),
+ /* 858 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 865 E> */ B(StoreICSloppy), R(0), U8(0), U8(121),
+ /* 872 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 879 E> */ B(StoreICSloppy), R(0), U8(0), U8(123),
+ /* 886 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 893 E> */ B(StoreICSloppy), R(0), U8(0), U8(125),
+ /* 900 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 907 E> */ B(StoreICSloppy), R(0), U8(0), U8(127),
+ /* 914 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 921 E> */ B(StoreICSloppy), R(0), U8(0), U8(129),
+ /* 928 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 935 E> */ B(StoreICSloppy), R(0), U8(0), U8(131),
+ /* 942 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 949 E> */ B(StoreICSloppy), R(0), U8(0), U8(133),
+ /* 956 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 963 E> */ B(StoreICSloppy), R(0), U8(0), U8(135),
+ /* 970 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 977 E> */ B(StoreICSloppy), R(0), U8(0), U8(137),
+ /* 984 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 991 E> */ B(StoreICSloppy), R(0), U8(0), U8(139),
+ /* 998 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1005 E> */ B(StoreICSloppy), R(0), U8(0), U8(141),
+ /* 1012 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1019 E> */ B(StoreICSloppy), R(0), U8(0), U8(143),
+ /* 1026 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1033 E> */ B(StoreICSloppy), R(0), U8(0), U8(145),
+ /* 1040 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1047 E> */ B(StoreICSloppy), R(0), U8(0), U8(147),
+ /* 1054 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1061 E> */ B(StoreICSloppy), R(0), U8(0), U8(149),
+ /* 1068 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1075 E> */ B(StoreICSloppy), R(0), U8(0), U8(151),
+ /* 1082 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1089 E> */ B(StoreICSloppy), R(0), U8(0), U8(153),
+ /* 1096 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1103 E> */ B(StoreICSloppy), R(0), U8(0), U8(155),
+ /* 1110 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1117 E> */ B(StoreICSloppy), R(0), U8(0), U8(157),
+ /* 1124 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1131 E> */ B(StoreICSloppy), R(0), U8(0), U8(159),
+ /* 1138 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1145 E> */ B(StoreICSloppy), R(0), U8(0), U8(161),
+ /* 1152 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1159 E> */ B(StoreICSloppy), R(0), U8(0), U8(163),
+ /* 1166 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1173 E> */ B(StoreICSloppy), R(0), U8(0), U8(165),
+ /* 1180 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1187 E> */ B(StoreICSloppy), R(0), U8(0), U8(167),
+ /* 1194 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1201 E> */ B(StoreICSloppy), R(0), U8(0), U8(169),
+ /* 1208 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1215 E> */ B(StoreICSloppy), R(0), U8(0), U8(171),
+ /* 1222 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1229 E> */ B(StoreICSloppy), R(0), U8(0), U8(173),
+ /* 1236 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1243 E> */ B(StoreICSloppy), R(0), U8(0), U8(175),
+ /* 1250 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1257 E> */ B(StoreICSloppy), R(0), U8(0), U8(177),
+ /* 1264 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1271 E> */ B(StoreICSloppy), R(0), U8(0), U8(179),
+ /* 1278 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1285 E> */ B(StoreICSloppy), R(0), U8(0), U8(181),
+ /* 1292 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1299 E> */ B(StoreICSloppy), R(0), U8(0), U8(183),
+ /* 1306 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1313 E> */ B(StoreICSloppy), R(0), U8(0), U8(185),
+ /* 1320 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1327 E> */ B(StoreICSloppy), R(0), U8(0), U8(187),
+ /* 1334 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1341 E> */ B(StoreICSloppy), R(0), U8(0), U8(189),
+ /* 1348 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1355 E> */ B(StoreICSloppy), R(0), U8(0), U8(191),
+ /* 1362 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1369 E> */ B(StoreICSloppy), R(0), U8(0), U8(193),
+ /* 1376 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1383 E> */ B(StoreICSloppy), R(0), U8(0), U8(195),
+ /* 1390 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1397 E> */ B(StoreICSloppy), R(0), U8(0), U8(197),
+ /* 1404 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1411 E> */ B(StoreICSloppy), R(0), U8(0), U8(199),
+ /* 1418 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1425 E> */ B(StoreICSloppy), R(0), U8(0), U8(201),
+ /* 1432 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1439 E> */ B(StoreICSloppy), R(0), U8(0), U8(203),
+ /* 1446 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1453 E> */ B(StoreICSloppy), R(0), U8(0), U8(205),
+ /* 1460 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1467 E> */ B(StoreICSloppy), R(0), U8(0), U8(207),
+ /* 1474 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1481 E> */ B(StoreICSloppy), R(0), U8(0), U8(209),
+ /* 1488 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1495 E> */ B(StoreICSloppy), R(0), U8(0), U8(211),
+ /* 1502 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1509 E> */ B(StoreICSloppy), R(0), U8(0), U8(213),
+ /* 1516 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1523 E> */ B(StoreICSloppy), R(0), U8(0), U8(215),
+ /* 1530 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1537 E> */ B(StoreICSloppy), R(0), U8(0), U8(217),
+ /* 1544 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1551 E> */ B(StoreICSloppy), R(0), U8(0), U8(219),
+ /* 1558 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1565 E> */ B(StoreICSloppy), R(0), U8(0), U8(221),
+ /* 1572 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1579 E> */ B(StoreICSloppy), R(0), U8(0), U8(223),
+ /* 1586 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1593 E> */ B(StoreICSloppy), R(0), U8(0), U8(225),
+ /* 1600 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1607 E> */ B(StoreICSloppy), R(0), U8(0), U8(227),
+ /* 1614 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1621 E> */ B(StoreICSloppy), R(0), U8(0), U8(229),
+ /* 1628 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1635 E> */ B(StoreICSloppy), R(0), U8(0), U8(231),
+ /* 1642 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1649 E> */ B(StoreICSloppy), R(0), U8(0), U8(233),
+ /* 1656 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1663 E> */ B(StoreICSloppy), R(0), U8(0), U8(235),
+ /* 1670 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1677 E> */ B(StoreICSloppy), R(0), U8(0), U8(237),
+ /* 1684 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1691 E> */ B(StoreICSloppy), R(0), U8(0), U8(239),
+ /* 1698 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1705 E> */ B(StoreICSloppy), R(0), U8(0), U8(241),
+ /* 1712 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1719 E> */ B(StoreICSloppy), R(0), U8(0), U8(243),
+ /* 1726 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1733 E> */ B(StoreICSloppy), R(0), U8(0), U8(245),
+ /* 1740 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1747 E> */ B(StoreICSloppy), R(0), U8(0), U8(247),
+ /* 1754 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1761 E> */ B(StoreICSloppy), R(0), U8(0), U8(249),
+ /* 1768 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1775 E> */ B(StoreICSloppy), R(0), U8(0), U8(251),
+ /* 1782 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1789 E> */ B(StoreICSloppy), R(0), U8(0), U8(253),
+ /* 1796 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1803 E> */ B(StoreICSloppy), R(0), U8(0), U8(255),
+ /* 1810 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(2),
+ /* 1817 E> */ B(Wide), B(StoreICSloppy), R16(0), U16(0), U16(257),
+ B(LdaUndefined),
+ /* 1822 S> */ B(Return),
]
constant pool: [
"name",
@@ -986,525 +986,525 @@
parameter count: 2
bytecode array length: 1297
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(1),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(3),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(5),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(7),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(9),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(11),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(13),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(15),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(17),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(19),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(21),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(23),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(25),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(27),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(29),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(31),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(33),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(35),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(37),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(39),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(41),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(43),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(45),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(47),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(49),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(51),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(53),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(55),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(57),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(59),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(61),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(63),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(65),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(67),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(69),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(71),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(73),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(75),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(77),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(79),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(81),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(83),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(85),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(87),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(89),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(91),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(93),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(95),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(97),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(99),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(101),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(103),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(105),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(107),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(109),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(111),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(113),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(115),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(117),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(119),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(121),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(123),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(125),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(127),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(129),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(131),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(133),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(135),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(137),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(139),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(141),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(143),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(145),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(147),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(149),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(151),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(153),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(155),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(157),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(159),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(161),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(163),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(165),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(167),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(169),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(171),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(173),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(175),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(177),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(179),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(181),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(183),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(185),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(187),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(189),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(191),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(193),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(195),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(197),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(199),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(201),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(203),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(205),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(207),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(209),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(211),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(213),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(215),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(217),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(219),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(221),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(223),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(225),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(227),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(229),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(231),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(233),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(235),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(237),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(239),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(241),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(243),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(245),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(247),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(249),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(251),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(253),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(1),
- B(StoreICStrict), R(0), U8(0), U8(255),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(2),
- B(Wide), B(StoreICStrict), R16(0), U16(0), U16(257),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 33 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 40 E> */ B(StoreICStrict), R(0), U8(0), U8(1),
+ /* 47 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 54 E> */ B(StoreICStrict), R(0), U8(0), U8(3),
+ /* 61 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 68 E> */ B(StoreICStrict), R(0), U8(0), U8(5),
+ /* 75 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 82 E> */ B(StoreICStrict), R(0), U8(0), U8(7),
+ /* 89 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 96 E> */ B(StoreICStrict), R(0), U8(0), U8(9),
+ /* 103 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 110 E> */ B(StoreICStrict), R(0), U8(0), U8(11),
+ /* 117 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 124 E> */ B(StoreICStrict), R(0), U8(0), U8(13),
+ /* 131 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 138 E> */ B(StoreICStrict), R(0), U8(0), U8(15),
+ /* 145 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 152 E> */ B(StoreICStrict), R(0), U8(0), U8(17),
+ /* 159 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 166 E> */ B(StoreICStrict), R(0), U8(0), U8(19),
+ /* 173 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 180 E> */ B(StoreICStrict), R(0), U8(0), U8(21),
+ /* 187 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 194 E> */ B(StoreICStrict), R(0), U8(0), U8(23),
+ /* 201 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 208 E> */ B(StoreICStrict), R(0), U8(0), U8(25),
+ /* 215 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 222 E> */ B(StoreICStrict), R(0), U8(0), U8(27),
+ /* 229 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 236 E> */ B(StoreICStrict), R(0), U8(0), U8(29),
+ /* 243 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 250 E> */ B(StoreICStrict), R(0), U8(0), U8(31),
+ /* 257 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 264 E> */ B(StoreICStrict), R(0), U8(0), U8(33),
+ /* 271 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 278 E> */ B(StoreICStrict), R(0), U8(0), U8(35),
+ /* 285 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 292 E> */ B(StoreICStrict), R(0), U8(0), U8(37),
+ /* 299 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 306 E> */ B(StoreICStrict), R(0), U8(0), U8(39),
+ /* 313 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 320 E> */ B(StoreICStrict), R(0), U8(0), U8(41),
+ /* 327 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 334 E> */ B(StoreICStrict), R(0), U8(0), U8(43),
+ /* 341 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 348 E> */ B(StoreICStrict), R(0), U8(0), U8(45),
+ /* 355 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 362 E> */ B(StoreICStrict), R(0), U8(0), U8(47),
+ /* 369 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 376 E> */ B(StoreICStrict), R(0), U8(0), U8(49),
+ /* 383 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 390 E> */ B(StoreICStrict), R(0), U8(0), U8(51),
+ /* 397 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 404 E> */ B(StoreICStrict), R(0), U8(0), U8(53),
+ /* 411 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 418 E> */ B(StoreICStrict), R(0), U8(0), U8(55),
+ /* 425 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 432 E> */ B(StoreICStrict), R(0), U8(0), U8(57),
+ /* 439 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 446 E> */ B(StoreICStrict), R(0), U8(0), U8(59),
+ /* 453 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 460 E> */ B(StoreICStrict), R(0), U8(0), U8(61),
+ /* 467 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 474 E> */ B(StoreICStrict), R(0), U8(0), U8(63),
+ /* 481 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 488 E> */ B(StoreICStrict), R(0), U8(0), U8(65),
+ /* 495 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 502 E> */ B(StoreICStrict), R(0), U8(0), U8(67),
+ /* 509 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 516 E> */ B(StoreICStrict), R(0), U8(0), U8(69),
+ /* 523 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 530 E> */ B(StoreICStrict), R(0), U8(0), U8(71),
+ /* 537 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 544 E> */ B(StoreICStrict), R(0), U8(0), U8(73),
+ /* 551 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 558 E> */ B(StoreICStrict), R(0), U8(0), U8(75),
+ /* 565 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 572 E> */ B(StoreICStrict), R(0), U8(0), U8(77),
+ /* 579 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 586 E> */ B(StoreICStrict), R(0), U8(0), U8(79),
+ /* 593 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 600 E> */ B(StoreICStrict), R(0), U8(0), U8(81),
+ /* 607 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 614 E> */ B(StoreICStrict), R(0), U8(0), U8(83),
+ /* 621 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 628 E> */ B(StoreICStrict), R(0), U8(0), U8(85),
+ /* 635 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 642 E> */ B(StoreICStrict), R(0), U8(0), U8(87),
+ /* 649 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 656 E> */ B(StoreICStrict), R(0), U8(0), U8(89),
+ /* 663 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 670 E> */ B(StoreICStrict), R(0), U8(0), U8(91),
+ /* 677 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 684 E> */ B(StoreICStrict), R(0), U8(0), U8(93),
+ /* 691 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 698 E> */ B(StoreICStrict), R(0), U8(0), U8(95),
+ /* 705 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 712 E> */ B(StoreICStrict), R(0), U8(0), U8(97),
+ /* 719 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 726 E> */ B(StoreICStrict), R(0), U8(0), U8(99),
+ /* 733 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 740 E> */ B(StoreICStrict), R(0), U8(0), U8(101),
+ /* 747 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 754 E> */ B(StoreICStrict), R(0), U8(0), U8(103),
+ /* 761 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 768 E> */ B(StoreICStrict), R(0), U8(0), U8(105),
+ /* 775 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 782 E> */ B(StoreICStrict), R(0), U8(0), U8(107),
+ /* 789 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 796 E> */ B(StoreICStrict), R(0), U8(0), U8(109),
+ /* 803 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 810 E> */ B(StoreICStrict), R(0), U8(0), U8(111),
+ /* 817 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 824 E> */ B(StoreICStrict), R(0), U8(0), U8(113),
+ /* 831 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 838 E> */ B(StoreICStrict), R(0), U8(0), U8(115),
+ /* 845 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 852 E> */ B(StoreICStrict), R(0), U8(0), U8(117),
+ /* 859 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 866 E> */ B(StoreICStrict), R(0), U8(0), U8(119),
+ /* 873 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 880 E> */ B(StoreICStrict), R(0), U8(0), U8(121),
+ /* 887 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 894 E> */ B(StoreICStrict), R(0), U8(0), U8(123),
+ /* 901 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 908 E> */ B(StoreICStrict), R(0), U8(0), U8(125),
+ /* 915 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 922 E> */ B(StoreICStrict), R(0), U8(0), U8(127),
+ /* 929 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 936 E> */ B(StoreICStrict), R(0), U8(0), U8(129),
+ /* 943 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 950 E> */ B(StoreICStrict), R(0), U8(0), U8(131),
+ /* 957 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 964 E> */ B(StoreICStrict), R(0), U8(0), U8(133),
+ /* 971 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 978 E> */ B(StoreICStrict), R(0), U8(0), U8(135),
+ /* 985 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 992 E> */ B(StoreICStrict), R(0), U8(0), U8(137),
+ /* 999 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1006 E> */ B(StoreICStrict), R(0), U8(0), U8(139),
+ /* 1013 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1020 E> */ B(StoreICStrict), R(0), U8(0), U8(141),
+ /* 1027 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1034 E> */ B(StoreICStrict), R(0), U8(0), U8(143),
+ /* 1041 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1048 E> */ B(StoreICStrict), R(0), U8(0), U8(145),
+ /* 1055 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1062 E> */ B(StoreICStrict), R(0), U8(0), U8(147),
+ /* 1069 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1076 E> */ B(StoreICStrict), R(0), U8(0), U8(149),
+ /* 1083 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1090 E> */ B(StoreICStrict), R(0), U8(0), U8(151),
+ /* 1097 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1104 E> */ B(StoreICStrict), R(0), U8(0), U8(153),
+ /* 1111 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1118 E> */ B(StoreICStrict), R(0), U8(0), U8(155),
+ /* 1125 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1132 E> */ B(StoreICStrict), R(0), U8(0), U8(157),
+ /* 1139 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1146 E> */ B(StoreICStrict), R(0), U8(0), U8(159),
+ /* 1153 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1160 E> */ B(StoreICStrict), R(0), U8(0), U8(161),
+ /* 1167 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1174 E> */ B(StoreICStrict), R(0), U8(0), U8(163),
+ /* 1181 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1188 E> */ B(StoreICStrict), R(0), U8(0), U8(165),
+ /* 1195 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1202 E> */ B(StoreICStrict), R(0), U8(0), U8(167),
+ /* 1209 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1216 E> */ B(StoreICStrict), R(0), U8(0), U8(169),
+ /* 1223 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1230 E> */ B(StoreICStrict), R(0), U8(0), U8(171),
+ /* 1237 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1244 E> */ B(StoreICStrict), R(0), U8(0), U8(173),
+ /* 1251 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1258 E> */ B(StoreICStrict), R(0), U8(0), U8(175),
+ /* 1265 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1272 E> */ B(StoreICStrict), R(0), U8(0), U8(177),
+ /* 1279 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1286 E> */ B(StoreICStrict), R(0), U8(0), U8(179),
+ /* 1293 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1300 E> */ B(StoreICStrict), R(0), U8(0), U8(181),
+ /* 1307 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1314 E> */ B(StoreICStrict), R(0), U8(0), U8(183),
+ /* 1321 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1328 E> */ B(StoreICStrict), R(0), U8(0), U8(185),
+ /* 1335 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1342 E> */ B(StoreICStrict), R(0), U8(0), U8(187),
+ /* 1349 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1356 E> */ B(StoreICStrict), R(0), U8(0), U8(189),
+ /* 1363 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1370 E> */ B(StoreICStrict), R(0), U8(0), U8(191),
+ /* 1377 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1384 E> */ B(StoreICStrict), R(0), U8(0), U8(193),
+ /* 1391 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1398 E> */ B(StoreICStrict), R(0), U8(0), U8(195),
+ /* 1405 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1412 E> */ B(StoreICStrict), R(0), U8(0), U8(197),
+ /* 1419 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1426 E> */ B(StoreICStrict), R(0), U8(0), U8(199),
+ /* 1433 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1440 E> */ B(StoreICStrict), R(0), U8(0), U8(201),
+ /* 1447 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1454 E> */ B(StoreICStrict), R(0), U8(0), U8(203),
+ /* 1461 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1468 E> */ B(StoreICStrict), R(0), U8(0), U8(205),
+ /* 1475 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1482 E> */ B(StoreICStrict), R(0), U8(0), U8(207),
+ /* 1489 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1496 E> */ B(StoreICStrict), R(0), U8(0), U8(209),
+ /* 1503 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1510 E> */ B(StoreICStrict), R(0), U8(0), U8(211),
+ /* 1517 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1524 E> */ B(StoreICStrict), R(0), U8(0), U8(213),
+ /* 1531 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1538 E> */ B(StoreICStrict), R(0), U8(0), U8(215),
+ /* 1545 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1552 E> */ B(StoreICStrict), R(0), U8(0), U8(217),
+ /* 1559 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1566 E> */ B(StoreICStrict), R(0), U8(0), U8(219),
+ /* 1573 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1580 E> */ B(StoreICStrict), R(0), U8(0), U8(221),
+ /* 1587 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1594 E> */ B(StoreICStrict), R(0), U8(0), U8(223),
+ /* 1601 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1608 E> */ B(StoreICStrict), R(0), U8(0), U8(225),
+ /* 1615 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1622 E> */ B(StoreICStrict), R(0), U8(0), U8(227),
+ /* 1629 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1636 E> */ B(StoreICStrict), R(0), U8(0), U8(229),
+ /* 1643 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1650 E> */ B(StoreICStrict), R(0), U8(0), U8(231),
+ /* 1657 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1664 E> */ B(StoreICStrict), R(0), U8(0), U8(233),
+ /* 1671 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1678 E> */ B(StoreICStrict), R(0), U8(0), U8(235),
+ /* 1685 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1692 E> */ B(StoreICStrict), R(0), U8(0), U8(237),
+ /* 1699 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1706 E> */ B(StoreICStrict), R(0), U8(0), U8(239),
+ /* 1713 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1720 E> */ B(StoreICStrict), R(0), U8(0), U8(241),
+ /* 1727 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1734 E> */ B(StoreICStrict), R(0), U8(0), U8(243),
+ /* 1741 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1748 E> */ B(StoreICStrict), R(0), U8(0), U8(245),
+ /* 1755 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1762 E> */ B(StoreICStrict), R(0), U8(0), U8(247),
+ /* 1769 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1776 E> */ B(StoreICStrict), R(0), U8(0), U8(249),
+ /* 1783 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1790 E> */ B(StoreICStrict), R(0), U8(0), U8(251),
+ /* 1797 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1804 E> */ B(StoreICStrict), R(0), U8(0), U8(253),
+ /* 1811 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(1),
+ /* 1818 E> */ B(StoreICStrict), R(0), U8(0), U8(255),
+ /* 1825 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ B(LdaSmi), U8(2),
+ /* 1832 E> */ B(Wide), B(StoreICStrict), R16(0), U16(0), U16(257),
+ B(LdaUndefined),
+ /* 1837 S> */ B(Return),
]
constant pool: [
"name",
@@ -1651,783 +1651,783 @@
parameter count: 3
bytecode array length: 1813
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(1),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(3),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(5),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(7),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(9),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(11),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(13),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(15),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(17),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(19),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(21),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(23),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(25),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(27),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(29),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(31),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(33),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(35),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(37),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(39),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(41),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(43),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(45),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(47),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(49),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(51),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(53),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(55),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(57),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(59),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(61),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(63),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(65),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(67),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(69),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(71),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(73),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(75),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(77),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(79),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(81),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(83),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(85),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(87),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(89),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(91),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(93),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(95),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(97),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(99),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(101),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(103),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(105),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(107),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(109),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(111),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(113),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(115),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(117),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(119),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(121),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(123),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(125),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(127),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(129),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(131),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(133),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(135),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(137),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(139),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(141),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(143),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(145),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(147),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(149),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(151),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(153),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(155),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(157),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(159),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(161),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(163),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(165),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(167),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(169),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(171),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(173),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(175),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(177),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(179),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(181),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(183),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(185),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(187),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(189),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(191),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(193),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(195),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(197),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(199),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(201),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(203),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(205),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(207),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(209),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(211),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(213),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(215),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(217),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(219),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(221),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(223),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(225),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(227),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(229),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(231),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(233),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(235),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(237),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(239),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(241),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(243),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(245),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(247),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(249),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(251),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(253),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICSloppy), R(0), R(1), U8(255),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Wide), B(KeyedStoreICSloppy), R16(0), R16(1), U16(257),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 21 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 23 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 26 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(1),
+ /* 33 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 35 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 38 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(3),
+ /* 45 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 47 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 50 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(5),
+ /* 57 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 59 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 62 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(7),
+ /* 69 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 71 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 74 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(9),
+ /* 81 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 83 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 86 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(11),
+ /* 93 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 95 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 98 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(13),
+ /* 105 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 107 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 110 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(15),
+ /* 117 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 119 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 122 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(17),
+ /* 129 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 131 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 134 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(19),
+ /* 141 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 143 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 146 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(21),
+ /* 153 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 155 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 158 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(23),
+ /* 165 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 167 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 170 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(25),
+ /* 177 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 179 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 182 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(27),
+ /* 189 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 191 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 194 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(29),
+ /* 201 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 203 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 206 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(31),
+ /* 213 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 215 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 218 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(33),
+ /* 225 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 227 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 230 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(35),
+ /* 237 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 239 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 242 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(37),
+ /* 249 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 251 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 254 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(39),
+ /* 261 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 263 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 266 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(41),
+ /* 273 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 275 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 278 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(43),
+ /* 285 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 287 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 290 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(45),
+ /* 297 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 299 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 302 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(47),
+ /* 309 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 311 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 314 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(49),
+ /* 321 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 323 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 326 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(51),
+ /* 333 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 335 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 338 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(53),
+ /* 345 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 347 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 350 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(55),
+ /* 357 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 359 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 362 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(57),
+ /* 369 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 371 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 374 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(59),
+ /* 381 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 383 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 386 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(61),
+ /* 393 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 395 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 398 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(63),
+ /* 405 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 407 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 410 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(65),
+ /* 417 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 419 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 422 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(67),
+ /* 429 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 431 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 434 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(69),
+ /* 441 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 443 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 446 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(71),
+ /* 453 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 455 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 458 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(73),
+ /* 465 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 467 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 470 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(75),
+ /* 477 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 479 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 482 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(77),
+ /* 489 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 491 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 494 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(79),
+ /* 501 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 503 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 506 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(81),
+ /* 513 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 515 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 518 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(83),
+ /* 525 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 527 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 530 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(85),
+ /* 537 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 539 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 542 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(87),
+ /* 549 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 551 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 554 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(89),
+ /* 561 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 563 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 566 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(91),
+ /* 573 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 575 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 578 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(93),
+ /* 585 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 587 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 590 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(95),
+ /* 597 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 599 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 602 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(97),
+ /* 609 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 611 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 614 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(99),
+ /* 621 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 623 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 626 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(101),
+ /* 633 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 635 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 638 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(103),
+ /* 645 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 647 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 650 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(105),
+ /* 657 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 659 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 662 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(107),
+ /* 669 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 671 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 674 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(109),
+ /* 681 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 683 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 686 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(111),
+ /* 693 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 695 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 698 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(113),
+ /* 705 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 707 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 710 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(115),
+ /* 717 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 719 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 722 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(117),
+ /* 729 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 731 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 734 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(119),
+ /* 741 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 743 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 746 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(121),
+ /* 753 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 755 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 758 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(123),
+ /* 765 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 767 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 770 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(125),
+ /* 777 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 779 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 782 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(127),
+ /* 789 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 791 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 794 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(129),
+ /* 801 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 803 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 806 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(131),
+ /* 813 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 815 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 818 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(133),
+ /* 825 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 827 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 830 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(135),
+ /* 837 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 839 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 842 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(137),
+ /* 849 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 851 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 854 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(139),
+ /* 861 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 863 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 866 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(141),
+ /* 873 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 875 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 878 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(143),
+ /* 885 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 887 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 890 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(145),
+ /* 897 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 899 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 902 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(147),
+ /* 909 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 911 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 914 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(149),
+ /* 921 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 923 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 926 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(151),
+ /* 933 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 935 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 938 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(153),
+ /* 945 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 947 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 950 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(155),
+ /* 957 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 959 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 962 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(157),
+ /* 969 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 971 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 974 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(159),
+ /* 981 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 983 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 986 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(161),
+ /* 993 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 995 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 998 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(163),
+ /* 1005 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1007 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1010 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(165),
+ /* 1017 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1019 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1022 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(167),
+ /* 1029 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1031 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1034 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(169),
+ /* 1041 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1043 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1046 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(171),
+ /* 1053 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1055 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1058 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(173),
+ /* 1065 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1067 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1070 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(175),
+ /* 1077 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1079 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1082 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(177),
+ /* 1089 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1091 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1094 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(179),
+ /* 1101 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1103 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1106 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(181),
+ /* 1113 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1115 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1118 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(183),
+ /* 1125 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1127 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1130 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(185),
+ /* 1137 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1139 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1142 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(187),
+ /* 1149 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1151 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1154 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(189),
+ /* 1161 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1163 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1166 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(191),
+ /* 1173 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1175 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1178 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(193),
+ /* 1185 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1187 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1190 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(195),
+ /* 1197 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1199 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1202 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(197),
+ /* 1209 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1211 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1214 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(199),
+ /* 1221 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1223 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1226 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(201),
+ /* 1233 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1235 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1238 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(203),
+ /* 1245 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1247 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1250 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(205),
+ /* 1257 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1259 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1262 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(207),
+ /* 1269 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1271 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1274 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(209),
+ /* 1281 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1283 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1286 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(211),
+ /* 1293 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1295 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1298 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(213),
+ /* 1305 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1307 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1310 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(215),
+ /* 1317 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1319 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1322 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(217),
+ /* 1329 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1331 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1334 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(219),
+ /* 1341 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1343 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1346 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(221),
+ /* 1353 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1355 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1358 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(223),
+ /* 1365 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1367 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1370 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(225),
+ /* 1377 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1379 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1382 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(227),
+ /* 1389 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1391 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1394 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(229),
+ /* 1401 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1403 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1406 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(231),
+ /* 1413 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1415 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1418 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(233),
+ /* 1425 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1427 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1430 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(235),
+ /* 1437 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1439 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1442 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(237),
+ /* 1449 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1451 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1454 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(239),
+ /* 1461 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1463 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1466 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(241),
+ /* 1473 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1475 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1478 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(243),
+ /* 1485 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1487 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1490 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(245),
+ /* 1497 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1499 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1502 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(247),
+ /* 1509 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1511 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1514 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(249),
+ /* 1521 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1523 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1526 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(251),
+ /* 1533 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1535 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1538 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(253),
+ /* 1545 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1547 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1550 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(255),
+ /* 1557 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1559 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 1562 E> */ B(Wide), B(KeyedStoreICSloppy), R16(0), R16(1), U16(257),
+ B(LdaUndefined),
+ /* 1567 S> */ B(Return),
]
constant pool: [
]
@@ -2574,783 +2574,783 @@
parameter count: 3
bytecode array length: 1813
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(1),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(3),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(5),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(7),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(9),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(11),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(13),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(15),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(17),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(19),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(21),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(23),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(25),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(27),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(29),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(31),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(33),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(35),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(37),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(39),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(41),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(43),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(45),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(47),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(49),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(51),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(53),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(55),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(57),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(59),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(61),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(63),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(65),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(67),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(69),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(71),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(73),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(75),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(77),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(79),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(81),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(83),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(85),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(87),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(89),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(91),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(93),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(95),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(97),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(99),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(101),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(103),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(105),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(107),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(109),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(111),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(113),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(115),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(117),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(119),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(121),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(123),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(125),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(127),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(129),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(131),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(133),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(135),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(137),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(139),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(141),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(143),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(145),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(147),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(149),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(151),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(153),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(155),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(157),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(159),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(161),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(163),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(165),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(167),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(169),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(171),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(173),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(175),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(177),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(179),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(181),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(183),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(185),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(187),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(189),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(191),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(193),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(195),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(197),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(199),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(201),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(203),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(205),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(207),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(209),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(211),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(213),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(215),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(217),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(219),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(221),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(223),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(225),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(227),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(229),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(231),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(233),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(235),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(237),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(239),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(241),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(243),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(245),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(247),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(249),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(251),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(253),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(KeyedStoreICStrict), R(0), R(1), U8(255),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(Ldar), R(arg1),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Wide), B(KeyedStoreICStrict), R16(0), R16(1), U16(257),
- B(LdaUndefined),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 37 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 39 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 42 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(1),
+ /* 49 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 51 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 54 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(3),
+ /* 61 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 63 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 66 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(5),
+ /* 73 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 75 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 78 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(7),
+ /* 85 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 87 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 90 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(9),
+ /* 97 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 99 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 102 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(11),
+ /* 109 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 111 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 114 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(13),
+ /* 121 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 123 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 126 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(15),
+ /* 133 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 135 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 138 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(17),
+ /* 145 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 147 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 150 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(19),
+ /* 157 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 159 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 162 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(21),
+ /* 169 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 171 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 174 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(23),
+ /* 181 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 183 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 186 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(25),
+ /* 193 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 195 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 198 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(27),
+ /* 205 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 207 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 210 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(29),
+ /* 217 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 219 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 222 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(31),
+ /* 229 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 231 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 234 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(33),
+ /* 241 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 243 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 246 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(35),
+ /* 253 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 255 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 258 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(37),
+ /* 265 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 267 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 270 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(39),
+ /* 277 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 279 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 282 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(41),
+ /* 289 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 291 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 294 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(43),
+ /* 301 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 303 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 306 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(45),
+ /* 313 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 315 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 318 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(47),
+ /* 325 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 327 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 330 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(49),
+ /* 337 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 339 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 342 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(51),
+ /* 349 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 351 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 354 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(53),
+ /* 361 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 363 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 366 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(55),
+ /* 373 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 375 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 378 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(57),
+ /* 385 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 387 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 390 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(59),
+ /* 397 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 399 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 402 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(61),
+ /* 409 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 411 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 414 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(63),
+ /* 421 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 423 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 426 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(65),
+ /* 433 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 435 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 438 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(67),
+ /* 445 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 447 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 450 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(69),
+ /* 457 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 459 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 462 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(71),
+ /* 469 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 471 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 474 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(73),
+ /* 481 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 483 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 486 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(75),
+ /* 493 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 495 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 498 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(77),
+ /* 505 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 507 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 510 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(79),
+ /* 517 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 519 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 522 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(81),
+ /* 529 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 531 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 534 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(83),
+ /* 541 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 543 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 546 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(85),
+ /* 553 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 555 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 558 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(87),
+ /* 565 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 567 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 570 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(89),
+ /* 577 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 579 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 582 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(91),
+ /* 589 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 591 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 594 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(93),
+ /* 601 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 603 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 606 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(95),
+ /* 613 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 615 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 618 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(97),
+ /* 625 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 627 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 630 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(99),
+ /* 637 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 639 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 642 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(101),
+ /* 649 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 651 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 654 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(103),
+ /* 661 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 663 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 666 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(105),
+ /* 673 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 675 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 678 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(107),
+ /* 685 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 687 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 690 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(109),
+ /* 697 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 699 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 702 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(111),
+ /* 709 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 711 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 714 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(113),
+ /* 721 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 723 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 726 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(115),
+ /* 733 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 735 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 738 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(117),
+ /* 745 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 747 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 750 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(119),
+ /* 757 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 759 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 762 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(121),
+ /* 769 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 771 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 774 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(123),
+ /* 781 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 783 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 786 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(125),
+ /* 793 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 795 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 798 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(127),
+ /* 805 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 807 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 810 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(129),
+ /* 817 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 819 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 822 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(131),
+ /* 829 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 831 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 834 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(133),
+ /* 841 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 843 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 846 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(135),
+ /* 853 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 855 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 858 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(137),
+ /* 865 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 867 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 870 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(139),
+ /* 877 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 879 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 882 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(141),
+ /* 889 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 891 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 894 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(143),
+ /* 901 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 903 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 906 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(145),
+ /* 913 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 915 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 918 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(147),
+ /* 925 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 927 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 930 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(149),
+ /* 937 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 939 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 942 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(151),
+ /* 949 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 951 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 954 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(153),
+ /* 961 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 963 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 966 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(155),
+ /* 973 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 975 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 978 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(157),
+ /* 985 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 987 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 990 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(159),
+ /* 997 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 999 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1002 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(161),
+ /* 1009 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1011 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1014 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(163),
+ /* 1021 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1023 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1026 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(165),
+ /* 1033 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1035 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1038 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(167),
+ /* 1045 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1047 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1050 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(169),
+ /* 1057 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1059 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1062 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(171),
+ /* 1069 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1071 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1074 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(173),
+ /* 1081 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1083 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1086 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(175),
+ /* 1093 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1095 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1098 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(177),
+ /* 1105 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1107 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1110 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(179),
+ /* 1117 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1119 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1122 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(181),
+ /* 1129 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1131 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1134 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(183),
+ /* 1141 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1143 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1146 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(185),
+ /* 1153 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1155 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1158 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(187),
+ /* 1165 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1167 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1170 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(189),
+ /* 1177 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1179 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1182 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(191),
+ /* 1189 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1191 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1194 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(193),
+ /* 1201 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1203 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1206 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(195),
+ /* 1213 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1215 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1218 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(197),
+ /* 1225 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1227 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1230 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(199),
+ /* 1237 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1239 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1242 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(201),
+ /* 1249 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1251 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1254 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(203),
+ /* 1261 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1263 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1266 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(205),
+ /* 1273 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1275 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1278 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(207),
+ /* 1285 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1287 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1290 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(209),
+ /* 1297 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1299 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1302 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(211),
+ /* 1309 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1311 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1314 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(213),
+ /* 1321 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1323 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1326 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(215),
+ /* 1333 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1335 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1338 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(217),
+ /* 1345 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1347 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1350 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(219),
+ /* 1357 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1359 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1362 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(221),
+ /* 1369 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1371 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1374 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(223),
+ /* 1381 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1383 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1386 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(225),
+ /* 1393 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1395 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1398 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(227),
+ /* 1405 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1407 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1410 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(229),
+ /* 1417 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1419 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1422 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(231),
+ /* 1429 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1431 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1434 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(233),
+ /* 1441 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1443 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1446 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(235),
+ /* 1453 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1455 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1458 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(237),
+ /* 1465 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1467 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1470 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(239),
+ /* 1477 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1479 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1482 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(241),
+ /* 1489 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1491 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1494 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(243),
+ /* 1501 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1503 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1506 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(245),
+ /* 1513 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1515 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1518 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(247),
+ /* 1525 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1527 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1530 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(249),
+ /* 1537 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1539 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1542 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(251),
+ /* 1549 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1551 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1554 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(253),
+ /* 1561 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1563 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ /* 1566 E> */ B(KeyedStoreICStrict), R(0), R(1), U8(255),
+ /* 1573 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1575 E> */ B(Ldar), R(arg1),
+ B(Star), R(1),
+ B(LdaSmi), U8(2),
+ /* 1578 E> */ B(Wide), B(KeyedStoreICStrict), R16(0), R16(1), U16(257),
+ B(LdaUndefined),
+ /* 1583 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/RegExpLiterals.golden b/test/cctest/interpreter/bytecode_expectations/RegExpLiterals.golden
index adffb75..01ae49c 100644
--- a/test/cctest/interpreter/bytecode_expectations/RegExpLiterals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/RegExpLiterals.golden
@@ -15,9 +15,9 @@
parameter count: 1
bytecode array length: 6
bytecodes: [
- B(StackCheck),
- B(CreateRegExpLiteral), U8(0), U8(0), U8(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateRegExpLiteral), U8(0), U8(0), U8(0),
+ /* 49 S> */ B(Return),
]
constant pool: [
"ab+d",
@@ -33,9 +33,9 @@
parameter count: 1
bytecode array length: 6
bytecodes: [
- B(StackCheck),
- B(CreateRegExpLiteral), U8(0), U8(0), U8(2),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateRegExpLiteral), U8(0), U8(0), U8(2),
+ /* 58 S> */ B(Return),
]
constant pool: [
"(\x5cw+)\x5cs(\x5cw+)",
@@ -51,15 +51,15 @@
parameter count: 1
bytecode array length: 23
bytecodes: [
- B(StackCheck),
- B(CreateRegExpLiteral), U8(0), U8(0), U8(0),
- B(Star), R(1),
- B(LoadIC), R(1), U8(1), U8(3),
- B(Star), R(0),
- B(LdaConstant), U8(2),
- B(Star), R(2),
- B(Call), R(0), R(1), U8(2), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateRegExpLiteral), U8(0), U8(0), U8(0),
+ B(Star), R(1),
+ /* 47 E> */ B(LoadIC), R(1), U8(1), U8(3),
+ B(Star), R(0),
+ B(LdaConstant), U8(2),
+ B(Star), R(2),
+ /* 48 E> */ B(Call), R(0), R(1), U8(2), U8(1),
+ /* 62 S> */ B(Return),
]
constant pool: [
"ab+d",
diff --git a/test/cctest/interpreter/bytecode_expectations/RegExpLiteralsWide.golden b/test/cctest/interpreter/bytecode_expectations/RegExpLiteralsWide.golden
index d6fb160..a8345a6 100644
--- a/test/cctest/interpreter/bytecode_expectations/RegExpLiteralsWide.golden
+++ b/test/cctest/interpreter/bytecode_expectations/RegExpLiteralsWide.golden
@@ -272,521 +272,521 @@
parameter count: 1
bytecode array length: 1033
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(2),
- B(Star), R(0),
- B(LdaConstant), U8(3),
- B(Star), R(0),
- B(LdaConstant), U8(4),
- B(Star), R(0),
- B(LdaConstant), U8(5),
- B(Star), R(0),
- B(LdaConstant), U8(6),
- B(Star), R(0),
- B(LdaConstant), U8(7),
- B(Star), R(0),
- B(LdaConstant), U8(8),
- B(Star), R(0),
- B(LdaConstant), U8(9),
- B(Star), R(0),
- B(LdaConstant), U8(10),
- B(Star), R(0),
- B(LdaConstant), U8(11),
- B(Star), R(0),
- B(LdaConstant), U8(12),
- B(Star), R(0),
- B(LdaConstant), U8(13),
- B(Star), R(0),
- B(LdaConstant), U8(14),
- B(Star), R(0),
- B(LdaConstant), U8(15),
- B(Star), R(0),
- B(LdaConstant), U8(16),
- B(Star), R(0),
- B(LdaConstant), U8(17),
- B(Star), R(0),
- B(LdaConstant), U8(18),
- B(Star), R(0),
- B(LdaConstant), U8(19),
- B(Star), R(0),
- B(LdaConstant), U8(20),
- B(Star), R(0),
- B(LdaConstant), U8(21),
- B(Star), R(0),
- B(LdaConstant), U8(22),
- B(Star), R(0),
- B(LdaConstant), U8(23),
- B(Star), R(0),
- B(LdaConstant), U8(24),
- B(Star), R(0),
- B(LdaConstant), U8(25),
- B(Star), R(0),
- B(LdaConstant), U8(26),
- B(Star), R(0),
- B(LdaConstant), U8(27),
- B(Star), R(0),
- B(LdaConstant), U8(28),
- B(Star), R(0),
- B(LdaConstant), U8(29),
- B(Star), R(0),
- B(LdaConstant), U8(30),
- B(Star), R(0),
- B(LdaConstant), U8(31),
- B(Star), R(0),
- B(LdaConstant), U8(32),
- B(Star), R(0),
- B(LdaConstant), U8(33),
- B(Star), R(0),
- B(LdaConstant), U8(34),
- B(Star), R(0),
- B(LdaConstant), U8(35),
- B(Star), R(0),
- B(LdaConstant), U8(36),
- B(Star), R(0),
- B(LdaConstant), U8(37),
- B(Star), R(0),
- B(LdaConstant), U8(38),
- B(Star), R(0),
- B(LdaConstant), U8(39),
- B(Star), R(0),
- B(LdaConstant), U8(40),
- B(Star), R(0),
- B(LdaConstant), U8(41),
- B(Star), R(0),
- B(LdaConstant), U8(42),
- B(Star), R(0),
- B(LdaConstant), U8(43),
- B(Star), R(0),
- B(LdaConstant), U8(44),
- B(Star), R(0),
- B(LdaConstant), U8(45),
- B(Star), R(0),
- B(LdaConstant), U8(46),
- B(Star), R(0),
- B(LdaConstant), U8(47),
- B(Star), R(0),
- B(LdaConstant), U8(48),
- B(Star), R(0),
- B(LdaConstant), U8(49),
- B(Star), R(0),
- B(LdaConstant), U8(50),
- B(Star), R(0),
- B(LdaConstant), U8(51),
- B(Star), R(0),
- B(LdaConstant), U8(52),
- B(Star), R(0),
- B(LdaConstant), U8(53),
- B(Star), R(0),
- B(LdaConstant), U8(54),
- B(Star), R(0),
- B(LdaConstant), U8(55),
- B(Star), R(0),
- B(LdaConstant), U8(56),
- B(Star), R(0),
- B(LdaConstant), U8(57),
- B(Star), R(0),
- B(LdaConstant), U8(58),
- B(Star), R(0),
- B(LdaConstant), U8(59),
- B(Star), R(0),
- B(LdaConstant), U8(60),
- B(Star), R(0),
- B(LdaConstant), U8(61),
- B(Star), R(0),
- B(LdaConstant), U8(62),
- B(Star), R(0),
- B(LdaConstant), U8(63),
- B(Star), R(0),
- B(LdaConstant), U8(64),
- B(Star), R(0),
- B(LdaConstant), U8(65),
- B(Star), R(0),
- B(LdaConstant), U8(66),
- B(Star), R(0),
- B(LdaConstant), U8(67),
- B(Star), R(0),
- B(LdaConstant), U8(68),
- B(Star), R(0),
- B(LdaConstant), U8(69),
- B(Star), R(0),
- B(LdaConstant), U8(70),
- B(Star), R(0),
- B(LdaConstant), U8(71),
- B(Star), R(0),
- B(LdaConstant), U8(72),
- B(Star), R(0),
- B(LdaConstant), U8(73),
- B(Star), R(0),
- B(LdaConstant), U8(74),
- B(Star), R(0),
- B(LdaConstant), U8(75),
- B(Star), R(0),
- B(LdaConstant), U8(76),
- B(Star), R(0),
- B(LdaConstant), U8(77),
- B(Star), R(0),
- B(LdaConstant), U8(78),
- B(Star), R(0),
- B(LdaConstant), U8(79),
- B(Star), R(0),
- B(LdaConstant), U8(80),
- B(Star), R(0),
- B(LdaConstant), U8(81),
- B(Star), R(0),
- B(LdaConstant), U8(82),
- B(Star), R(0),
- B(LdaConstant), U8(83),
- B(Star), R(0),
- B(LdaConstant), U8(84),
- B(Star), R(0),
- B(LdaConstant), U8(85),
- B(Star), R(0),
- B(LdaConstant), U8(86),
- B(Star), R(0),
- B(LdaConstant), U8(87),
- B(Star), R(0),
- B(LdaConstant), U8(88),
- B(Star), R(0),
- B(LdaConstant), U8(89),
- B(Star), R(0),
- B(LdaConstant), U8(90),
- B(Star), R(0),
- B(LdaConstant), U8(91),
- B(Star), R(0),
- B(LdaConstant), U8(92),
- B(Star), R(0),
- B(LdaConstant), U8(93),
- B(Star), R(0),
- B(LdaConstant), U8(94),
- B(Star), R(0),
- B(LdaConstant), U8(95),
- B(Star), R(0),
- B(LdaConstant), U8(96),
- B(Star), R(0),
- B(LdaConstant), U8(97),
- B(Star), R(0),
- B(LdaConstant), U8(98),
- B(Star), R(0),
- B(LdaConstant), U8(99),
- B(Star), R(0),
- B(LdaConstant), U8(100),
- B(Star), R(0),
- B(LdaConstant), U8(101),
- B(Star), R(0),
- B(LdaConstant), U8(102),
- B(Star), R(0),
- B(LdaConstant), U8(103),
- B(Star), R(0),
- B(LdaConstant), U8(104),
- B(Star), R(0),
- B(LdaConstant), U8(105),
- B(Star), R(0),
- B(LdaConstant), U8(106),
- B(Star), R(0),
- B(LdaConstant), U8(107),
- B(Star), R(0),
- B(LdaConstant), U8(108),
- B(Star), R(0),
- B(LdaConstant), U8(109),
- B(Star), R(0),
- B(LdaConstant), U8(110),
- B(Star), R(0),
- B(LdaConstant), U8(111),
- B(Star), R(0),
- B(LdaConstant), U8(112),
- B(Star), R(0),
- B(LdaConstant), U8(113),
- B(Star), R(0),
- B(LdaConstant), U8(114),
- B(Star), R(0),
- B(LdaConstant), U8(115),
- B(Star), R(0),
- B(LdaConstant), U8(116),
- B(Star), R(0),
- B(LdaConstant), U8(117),
- B(Star), R(0),
- B(LdaConstant), U8(118),
- B(Star), R(0),
- B(LdaConstant), U8(119),
- B(Star), R(0),
- B(LdaConstant), U8(120),
- B(Star), R(0),
- B(LdaConstant), U8(121),
- B(Star), R(0),
- B(LdaConstant), U8(122),
- B(Star), R(0),
- B(LdaConstant), U8(123),
- B(Star), R(0),
- B(LdaConstant), U8(124),
- B(Star), R(0),
- B(LdaConstant), U8(125),
- B(Star), R(0),
- B(LdaConstant), U8(126),
- B(Star), R(0),
- B(LdaConstant), U8(127),
- B(Star), R(0),
- B(LdaConstant), U8(128),
- B(Star), R(0),
- B(LdaConstant), U8(129),
- B(Star), R(0),
- B(LdaConstant), U8(130),
- B(Star), R(0),
- B(LdaConstant), U8(131),
- B(Star), R(0),
- B(LdaConstant), U8(132),
- B(Star), R(0),
- B(LdaConstant), U8(133),
- B(Star), R(0),
- B(LdaConstant), U8(134),
- B(Star), R(0),
- B(LdaConstant), U8(135),
- B(Star), R(0),
- B(LdaConstant), U8(136),
- B(Star), R(0),
- B(LdaConstant), U8(137),
- B(Star), R(0),
- B(LdaConstant), U8(138),
- B(Star), R(0),
- B(LdaConstant), U8(139),
- B(Star), R(0),
- B(LdaConstant), U8(140),
- B(Star), R(0),
- B(LdaConstant), U8(141),
- B(Star), R(0),
- B(LdaConstant), U8(142),
- B(Star), R(0),
- B(LdaConstant), U8(143),
- B(Star), R(0),
- B(LdaConstant), U8(144),
- B(Star), R(0),
- B(LdaConstant), U8(145),
- B(Star), R(0),
- B(LdaConstant), U8(146),
- B(Star), R(0),
- B(LdaConstant), U8(147),
- B(Star), R(0),
- B(LdaConstant), U8(148),
- B(Star), R(0),
- B(LdaConstant), U8(149),
- B(Star), R(0),
- B(LdaConstant), U8(150),
- B(Star), R(0),
- B(LdaConstant), U8(151),
- B(Star), R(0),
- B(LdaConstant), U8(152),
- B(Star), R(0),
- B(LdaConstant), U8(153),
- B(Star), R(0),
- B(LdaConstant), U8(154),
- B(Star), R(0),
- B(LdaConstant), U8(155),
- B(Star), R(0),
- B(LdaConstant), U8(156),
- B(Star), R(0),
- B(LdaConstant), U8(157),
- B(Star), R(0),
- B(LdaConstant), U8(158),
- B(Star), R(0),
- B(LdaConstant), U8(159),
- B(Star), R(0),
- B(LdaConstant), U8(160),
- B(Star), R(0),
- B(LdaConstant), U8(161),
- B(Star), R(0),
- B(LdaConstant), U8(162),
- B(Star), R(0),
- B(LdaConstant), U8(163),
- B(Star), R(0),
- B(LdaConstant), U8(164),
- B(Star), R(0),
- B(LdaConstant), U8(165),
- B(Star), R(0),
- B(LdaConstant), U8(166),
- B(Star), R(0),
- B(LdaConstant), U8(167),
- B(Star), R(0),
- B(LdaConstant), U8(168),
- B(Star), R(0),
- B(LdaConstant), U8(169),
- B(Star), R(0),
- B(LdaConstant), U8(170),
- B(Star), R(0),
- B(LdaConstant), U8(171),
- B(Star), R(0),
- B(LdaConstant), U8(172),
- B(Star), R(0),
- B(LdaConstant), U8(173),
- B(Star), R(0),
- B(LdaConstant), U8(174),
- B(Star), R(0),
- B(LdaConstant), U8(175),
- B(Star), R(0),
- B(LdaConstant), U8(176),
- B(Star), R(0),
- B(LdaConstant), U8(177),
- B(Star), R(0),
- B(LdaConstant), U8(178),
- B(Star), R(0),
- B(LdaConstant), U8(179),
- B(Star), R(0),
- B(LdaConstant), U8(180),
- B(Star), R(0),
- B(LdaConstant), U8(181),
- B(Star), R(0),
- B(LdaConstant), U8(182),
- B(Star), R(0),
- B(LdaConstant), U8(183),
- B(Star), R(0),
- B(LdaConstant), U8(184),
- B(Star), R(0),
- B(LdaConstant), U8(185),
- B(Star), R(0),
- B(LdaConstant), U8(186),
- B(Star), R(0),
- B(LdaConstant), U8(187),
- B(Star), R(0),
- B(LdaConstant), U8(188),
- B(Star), R(0),
- B(LdaConstant), U8(189),
- B(Star), R(0),
- B(LdaConstant), U8(190),
- B(Star), R(0),
- B(LdaConstant), U8(191),
- B(Star), R(0),
- B(LdaConstant), U8(192),
- B(Star), R(0),
- B(LdaConstant), U8(193),
- B(Star), R(0),
- B(LdaConstant), U8(194),
- B(Star), R(0),
- B(LdaConstant), U8(195),
- B(Star), R(0),
- B(LdaConstant), U8(196),
- B(Star), R(0),
- B(LdaConstant), U8(197),
- B(Star), R(0),
- B(LdaConstant), U8(198),
- B(Star), R(0),
- B(LdaConstant), U8(199),
- B(Star), R(0),
- B(LdaConstant), U8(200),
- B(Star), R(0),
- B(LdaConstant), U8(201),
- B(Star), R(0),
- B(LdaConstant), U8(202),
- B(Star), R(0),
- B(LdaConstant), U8(203),
- B(Star), R(0),
- B(LdaConstant), U8(204),
- B(Star), R(0),
- B(LdaConstant), U8(205),
- B(Star), R(0),
- B(LdaConstant), U8(206),
- B(Star), R(0),
- B(LdaConstant), U8(207),
- B(Star), R(0),
- B(LdaConstant), U8(208),
- B(Star), R(0),
- B(LdaConstant), U8(209),
- B(Star), R(0),
- B(LdaConstant), U8(210),
- B(Star), R(0),
- B(LdaConstant), U8(211),
- B(Star), R(0),
- B(LdaConstant), U8(212),
- B(Star), R(0),
- B(LdaConstant), U8(213),
- B(Star), R(0),
- B(LdaConstant), U8(214),
- B(Star), R(0),
- B(LdaConstant), U8(215),
- B(Star), R(0),
- B(LdaConstant), U8(216),
- B(Star), R(0),
- B(LdaConstant), U8(217),
- B(Star), R(0),
- B(LdaConstant), U8(218),
- B(Star), R(0),
- B(LdaConstant), U8(219),
- B(Star), R(0),
- B(LdaConstant), U8(220),
- B(Star), R(0),
- B(LdaConstant), U8(221),
- B(Star), R(0),
- B(LdaConstant), U8(222),
- B(Star), R(0),
- B(LdaConstant), U8(223),
- B(Star), R(0),
- B(LdaConstant), U8(224),
- B(Star), R(0),
- B(LdaConstant), U8(225),
- B(Star), R(0),
- B(LdaConstant), U8(226),
- B(Star), R(0),
- B(LdaConstant), U8(227),
- B(Star), R(0),
- B(LdaConstant), U8(228),
- B(Star), R(0),
- B(LdaConstant), U8(229),
- B(Star), R(0),
- B(LdaConstant), U8(230),
- B(Star), R(0),
- B(LdaConstant), U8(231),
- B(Star), R(0),
- B(LdaConstant), U8(232),
- B(Star), R(0),
- B(LdaConstant), U8(233),
- B(Star), R(0),
- B(LdaConstant), U8(234),
- B(Star), R(0),
- B(LdaConstant), U8(235),
- B(Star), R(0),
- B(LdaConstant), U8(236),
- B(Star), R(0),
- B(LdaConstant), U8(237),
- B(Star), R(0),
- B(LdaConstant), U8(238),
- B(Star), R(0),
- B(LdaConstant), U8(239),
- B(Star), R(0),
- B(LdaConstant), U8(240),
- B(Star), R(0),
- B(LdaConstant), U8(241),
- B(Star), R(0),
- B(LdaConstant), U8(242),
- B(Star), R(0),
- B(LdaConstant), U8(243),
- B(Star), R(0),
- B(LdaConstant), U8(244),
- B(Star), R(0),
- B(LdaConstant), U8(245),
- B(Star), R(0),
- B(LdaConstant), U8(246),
- B(Star), R(0),
- B(LdaConstant), U8(247),
- B(Star), R(0),
- B(LdaConstant), U8(248),
- B(Star), R(0),
- B(LdaConstant), U8(249),
- B(Star), R(0),
- B(LdaConstant), U8(250),
- B(Star), R(0),
- B(LdaConstant), U8(251),
- B(Star), R(0),
- B(LdaConstant), U8(252),
- B(Star), R(0),
- B(LdaConstant), U8(253),
- B(Star), R(0),
- B(LdaConstant), U8(254),
- B(Star), R(0),
- B(LdaConstant), U8(255),
- B(Star), R(0),
- B(Wide), B(CreateRegExpLiteral), U16(256), U16(0), U8(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 41 S> */ B(LdaConstant), U8(0),
+ /* 43 E> */ B(Star), R(0),
+ /* 51 S> */ B(LdaConstant), U8(1),
+ /* 53 E> */ B(Star), R(0),
+ /* 61 S> */ B(LdaConstant), U8(2),
+ /* 63 E> */ B(Star), R(0),
+ /* 71 S> */ B(LdaConstant), U8(3),
+ /* 73 E> */ B(Star), R(0),
+ /* 81 S> */ B(LdaConstant), U8(4),
+ /* 83 E> */ B(Star), R(0),
+ /* 91 S> */ B(LdaConstant), U8(5),
+ /* 93 E> */ B(Star), R(0),
+ /* 101 S> */ B(LdaConstant), U8(6),
+ /* 103 E> */ B(Star), R(0),
+ /* 111 S> */ B(LdaConstant), U8(7),
+ /* 113 E> */ B(Star), R(0),
+ /* 121 S> */ B(LdaConstant), U8(8),
+ /* 123 E> */ B(Star), R(0),
+ /* 131 S> */ B(LdaConstant), U8(9),
+ /* 133 E> */ B(Star), R(0),
+ /* 141 S> */ B(LdaConstant), U8(10),
+ /* 143 E> */ B(Star), R(0),
+ /* 151 S> */ B(LdaConstant), U8(11),
+ /* 153 E> */ B(Star), R(0),
+ /* 161 S> */ B(LdaConstant), U8(12),
+ /* 163 E> */ B(Star), R(0),
+ /* 171 S> */ B(LdaConstant), U8(13),
+ /* 173 E> */ B(Star), R(0),
+ /* 181 S> */ B(LdaConstant), U8(14),
+ /* 183 E> */ B(Star), R(0),
+ /* 191 S> */ B(LdaConstant), U8(15),
+ /* 193 E> */ B(Star), R(0),
+ /* 201 S> */ B(LdaConstant), U8(16),
+ /* 203 E> */ B(Star), R(0),
+ /* 211 S> */ B(LdaConstant), U8(17),
+ /* 213 E> */ B(Star), R(0),
+ /* 221 S> */ B(LdaConstant), U8(18),
+ /* 223 E> */ B(Star), R(0),
+ /* 231 S> */ B(LdaConstant), U8(19),
+ /* 233 E> */ B(Star), R(0),
+ /* 241 S> */ B(LdaConstant), U8(20),
+ /* 243 E> */ B(Star), R(0),
+ /* 251 S> */ B(LdaConstant), U8(21),
+ /* 253 E> */ B(Star), R(0),
+ /* 261 S> */ B(LdaConstant), U8(22),
+ /* 263 E> */ B(Star), R(0),
+ /* 271 S> */ B(LdaConstant), U8(23),
+ /* 273 E> */ B(Star), R(0),
+ /* 281 S> */ B(LdaConstant), U8(24),
+ /* 283 E> */ B(Star), R(0),
+ /* 291 S> */ B(LdaConstant), U8(25),
+ /* 293 E> */ B(Star), R(0),
+ /* 301 S> */ B(LdaConstant), U8(26),
+ /* 303 E> */ B(Star), R(0),
+ /* 311 S> */ B(LdaConstant), U8(27),
+ /* 313 E> */ B(Star), R(0),
+ /* 321 S> */ B(LdaConstant), U8(28),
+ /* 323 E> */ B(Star), R(0),
+ /* 331 S> */ B(LdaConstant), U8(29),
+ /* 333 E> */ B(Star), R(0),
+ /* 341 S> */ B(LdaConstant), U8(30),
+ /* 343 E> */ B(Star), R(0),
+ /* 351 S> */ B(LdaConstant), U8(31),
+ /* 353 E> */ B(Star), R(0),
+ /* 361 S> */ B(LdaConstant), U8(32),
+ /* 363 E> */ B(Star), R(0),
+ /* 371 S> */ B(LdaConstant), U8(33),
+ /* 373 E> */ B(Star), R(0),
+ /* 381 S> */ B(LdaConstant), U8(34),
+ /* 383 E> */ B(Star), R(0),
+ /* 391 S> */ B(LdaConstant), U8(35),
+ /* 393 E> */ B(Star), R(0),
+ /* 401 S> */ B(LdaConstant), U8(36),
+ /* 403 E> */ B(Star), R(0),
+ /* 411 S> */ B(LdaConstant), U8(37),
+ /* 413 E> */ B(Star), R(0),
+ /* 421 S> */ B(LdaConstant), U8(38),
+ /* 423 E> */ B(Star), R(0),
+ /* 431 S> */ B(LdaConstant), U8(39),
+ /* 433 E> */ B(Star), R(0),
+ /* 441 S> */ B(LdaConstant), U8(40),
+ /* 443 E> */ B(Star), R(0),
+ /* 451 S> */ B(LdaConstant), U8(41),
+ /* 453 E> */ B(Star), R(0),
+ /* 461 S> */ B(LdaConstant), U8(42),
+ /* 463 E> */ B(Star), R(0),
+ /* 471 S> */ B(LdaConstant), U8(43),
+ /* 473 E> */ B(Star), R(0),
+ /* 481 S> */ B(LdaConstant), U8(44),
+ /* 483 E> */ B(Star), R(0),
+ /* 491 S> */ B(LdaConstant), U8(45),
+ /* 493 E> */ B(Star), R(0),
+ /* 501 S> */ B(LdaConstant), U8(46),
+ /* 503 E> */ B(Star), R(0),
+ /* 511 S> */ B(LdaConstant), U8(47),
+ /* 513 E> */ B(Star), R(0),
+ /* 521 S> */ B(LdaConstant), U8(48),
+ /* 523 E> */ B(Star), R(0),
+ /* 531 S> */ B(LdaConstant), U8(49),
+ /* 533 E> */ B(Star), R(0),
+ /* 541 S> */ B(LdaConstant), U8(50),
+ /* 543 E> */ B(Star), R(0),
+ /* 551 S> */ B(LdaConstant), U8(51),
+ /* 553 E> */ B(Star), R(0),
+ /* 561 S> */ B(LdaConstant), U8(52),
+ /* 563 E> */ B(Star), R(0),
+ /* 571 S> */ B(LdaConstant), U8(53),
+ /* 573 E> */ B(Star), R(0),
+ /* 581 S> */ B(LdaConstant), U8(54),
+ /* 583 E> */ B(Star), R(0),
+ /* 591 S> */ B(LdaConstant), U8(55),
+ /* 593 E> */ B(Star), R(0),
+ /* 601 S> */ B(LdaConstant), U8(56),
+ /* 603 E> */ B(Star), R(0),
+ /* 611 S> */ B(LdaConstant), U8(57),
+ /* 613 E> */ B(Star), R(0),
+ /* 621 S> */ B(LdaConstant), U8(58),
+ /* 623 E> */ B(Star), R(0),
+ /* 631 S> */ B(LdaConstant), U8(59),
+ /* 633 E> */ B(Star), R(0),
+ /* 641 S> */ B(LdaConstant), U8(60),
+ /* 643 E> */ B(Star), R(0),
+ /* 651 S> */ B(LdaConstant), U8(61),
+ /* 653 E> */ B(Star), R(0),
+ /* 661 S> */ B(LdaConstant), U8(62),
+ /* 663 E> */ B(Star), R(0),
+ /* 671 S> */ B(LdaConstant), U8(63),
+ /* 673 E> */ B(Star), R(0),
+ /* 681 S> */ B(LdaConstant), U8(64),
+ /* 683 E> */ B(Star), R(0),
+ /* 691 S> */ B(LdaConstant), U8(65),
+ /* 693 E> */ B(Star), R(0),
+ /* 701 S> */ B(LdaConstant), U8(66),
+ /* 703 E> */ B(Star), R(0),
+ /* 711 S> */ B(LdaConstant), U8(67),
+ /* 713 E> */ B(Star), R(0),
+ /* 721 S> */ B(LdaConstant), U8(68),
+ /* 723 E> */ B(Star), R(0),
+ /* 731 S> */ B(LdaConstant), U8(69),
+ /* 733 E> */ B(Star), R(0),
+ /* 741 S> */ B(LdaConstant), U8(70),
+ /* 743 E> */ B(Star), R(0),
+ /* 751 S> */ B(LdaConstant), U8(71),
+ /* 753 E> */ B(Star), R(0),
+ /* 761 S> */ B(LdaConstant), U8(72),
+ /* 763 E> */ B(Star), R(0),
+ /* 771 S> */ B(LdaConstant), U8(73),
+ /* 773 E> */ B(Star), R(0),
+ /* 781 S> */ B(LdaConstant), U8(74),
+ /* 783 E> */ B(Star), R(0),
+ /* 791 S> */ B(LdaConstant), U8(75),
+ /* 793 E> */ B(Star), R(0),
+ /* 801 S> */ B(LdaConstant), U8(76),
+ /* 803 E> */ B(Star), R(0),
+ /* 811 S> */ B(LdaConstant), U8(77),
+ /* 813 E> */ B(Star), R(0),
+ /* 821 S> */ B(LdaConstant), U8(78),
+ /* 823 E> */ B(Star), R(0),
+ /* 831 S> */ B(LdaConstant), U8(79),
+ /* 833 E> */ B(Star), R(0),
+ /* 841 S> */ B(LdaConstant), U8(80),
+ /* 843 E> */ B(Star), R(0),
+ /* 851 S> */ B(LdaConstant), U8(81),
+ /* 853 E> */ B(Star), R(0),
+ /* 861 S> */ B(LdaConstant), U8(82),
+ /* 863 E> */ B(Star), R(0),
+ /* 871 S> */ B(LdaConstant), U8(83),
+ /* 873 E> */ B(Star), R(0),
+ /* 881 S> */ B(LdaConstant), U8(84),
+ /* 883 E> */ B(Star), R(0),
+ /* 891 S> */ B(LdaConstant), U8(85),
+ /* 893 E> */ B(Star), R(0),
+ /* 901 S> */ B(LdaConstant), U8(86),
+ /* 903 E> */ B(Star), R(0),
+ /* 911 S> */ B(LdaConstant), U8(87),
+ /* 913 E> */ B(Star), R(0),
+ /* 921 S> */ B(LdaConstant), U8(88),
+ /* 923 E> */ B(Star), R(0),
+ /* 931 S> */ B(LdaConstant), U8(89),
+ /* 933 E> */ B(Star), R(0),
+ /* 941 S> */ B(LdaConstant), U8(90),
+ /* 943 E> */ B(Star), R(0),
+ /* 951 S> */ B(LdaConstant), U8(91),
+ /* 953 E> */ B(Star), R(0),
+ /* 961 S> */ B(LdaConstant), U8(92),
+ /* 963 E> */ B(Star), R(0),
+ /* 971 S> */ B(LdaConstant), U8(93),
+ /* 973 E> */ B(Star), R(0),
+ /* 981 S> */ B(LdaConstant), U8(94),
+ /* 983 E> */ B(Star), R(0),
+ /* 991 S> */ B(LdaConstant), U8(95),
+ /* 993 E> */ B(Star), R(0),
+ /* 1001 S> */ B(LdaConstant), U8(96),
+ /* 1003 E> */ B(Star), R(0),
+ /* 1011 S> */ B(LdaConstant), U8(97),
+ /* 1013 E> */ B(Star), R(0),
+ /* 1021 S> */ B(LdaConstant), U8(98),
+ /* 1023 E> */ B(Star), R(0),
+ /* 1031 S> */ B(LdaConstant), U8(99),
+ /* 1033 E> */ B(Star), R(0),
+ /* 1041 S> */ B(LdaConstant), U8(100),
+ /* 1043 E> */ B(Star), R(0),
+ /* 1051 S> */ B(LdaConstant), U8(101),
+ /* 1053 E> */ B(Star), R(0),
+ /* 1061 S> */ B(LdaConstant), U8(102),
+ /* 1063 E> */ B(Star), R(0),
+ /* 1071 S> */ B(LdaConstant), U8(103),
+ /* 1073 E> */ B(Star), R(0),
+ /* 1081 S> */ B(LdaConstant), U8(104),
+ /* 1083 E> */ B(Star), R(0),
+ /* 1091 S> */ B(LdaConstant), U8(105),
+ /* 1093 E> */ B(Star), R(0),
+ /* 1101 S> */ B(LdaConstant), U8(106),
+ /* 1103 E> */ B(Star), R(0),
+ /* 1111 S> */ B(LdaConstant), U8(107),
+ /* 1113 E> */ B(Star), R(0),
+ /* 1121 S> */ B(LdaConstant), U8(108),
+ /* 1123 E> */ B(Star), R(0),
+ /* 1131 S> */ B(LdaConstant), U8(109),
+ /* 1133 E> */ B(Star), R(0),
+ /* 1141 S> */ B(LdaConstant), U8(110),
+ /* 1143 E> */ B(Star), R(0),
+ /* 1151 S> */ B(LdaConstant), U8(111),
+ /* 1153 E> */ B(Star), R(0),
+ /* 1161 S> */ B(LdaConstant), U8(112),
+ /* 1163 E> */ B(Star), R(0),
+ /* 1171 S> */ B(LdaConstant), U8(113),
+ /* 1173 E> */ B(Star), R(0),
+ /* 1181 S> */ B(LdaConstant), U8(114),
+ /* 1183 E> */ B(Star), R(0),
+ /* 1191 S> */ B(LdaConstant), U8(115),
+ /* 1193 E> */ B(Star), R(0),
+ /* 1201 S> */ B(LdaConstant), U8(116),
+ /* 1203 E> */ B(Star), R(0),
+ /* 1211 S> */ B(LdaConstant), U8(117),
+ /* 1213 E> */ B(Star), R(0),
+ /* 1221 S> */ B(LdaConstant), U8(118),
+ /* 1223 E> */ B(Star), R(0),
+ /* 1231 S> */ B(LdaConstant), U8(119),
+ /* 1233 E> */ B(Star), R(0),
+ /* 1241 S> */ B(LdaConstant), U8(120),
+ /* 1243 E> */ B(Star), R(0),
+ /* 1251 S> */ B(LdaConstant), U8(121),
+ /* 1253 E> */ B(Star), R(0),
+ /* 1261 S> */ B(LdaConstant), U8(122),
+ /* 1263 E> */ B(Star), R(0),
+ /* 1271 S> */ B(LdaConstant), U8(123),
+ /* 1273 E> */ B(Star), R(0),
+ /* 1281 S> */ B(LdaConstant), U8(124),
+ /* 1283 E> */ B(Star), R(0),
+ /* 1291 S> */ B(LdaConstant), U8(125),
+ /* 1293 E> */ B(Star), R(0),
+ /* 1301 S> */ B(LdaConstant), U8(126),
+ /* 1303 E> */ B(Star), R(0),
+ /* 1311 S> */ B(LdaConstant), U8(127),
+ /* 1313 E> */ B(Star), R(0),
+ /* 1321 S> */ B(LdaConstant), U8(128),
+ /* 1323 E> */ B(Star), R(0),
+ /* 1331 S> */ B(LdaConstant), U8(129),
+ /* 1333 E> */ B(Star), R(0),
+ /* 1341 S> */ B(LdaConstant), U8(130),
+ /* 1343 E> */ B(Star), R(0),
+ /* 1351 S> */ B(LdaConstant), U8(131),
+ /* 1353 E> */ B(Star), R(0),
+ /* 1361 S> */ B(LdaConstant), U8(132),
+ /* 1363 E> */ B(Star), R(0),
+ /* 1371 S> */ B(LdaConstant), U8(133),
+ /* 1373 E> */ B(Star), R(0),
+ /* 1381 S> */ B(LdaConstant), U8(134),
+ /* 1383 E> */ B(Star), R(0),
+ /* 1391 S> */ B(LdaConstant), U8(135),
+ /* 1393 E> */ B(Star), R(0),
+ /* 1401 S> */ B(LdaConstant), U8(136),
+ /* 1403 E> */ B(Star), R(0),
+ /* 1411 S> */ B(LdaConstant), U8(137),
+ /* 1413 E> */ B(Star), R(0),
+ /* 1421 S> */ B(LdaConstant), U8(138),
+ /* 1423 E> */ B(Star), R(0),
+ /* 1431 S> */ B(LdaConstant), U8(139),
+ /* 1433 E> */ B(Star), R(0),
+ /* 1441 S> */ B(LdaConstant), U8(140),
+ /* 1443 E> */ B(Star), R(0),
+ /* 1451 S> */ B(LdaConstant), U8(141),
+ /* 1453 E> */ B(Star), R(0),
+ /* 1461 S> */ B(LdaConstant), U8(142),
+ /* 1463 E> */ B(Star), R(0),
+ /* 1471 S> */ B(LdaConstant), U8(143),
+ /* 1473 E> */ B(Star), R(0),
+ /* 1481 S> */ B(LdaConstant), U8(144),
+ /* 1483 E> */ B(Star), R(0),
+ /* 1491 S> */ B(LdaConstant), U8(145),
+ /* 1493 E> */ B(Star), R(0),
+ /* 1501 S> */ B(LdaConstant), U8(146),
+ /* 1503 E> */ B(Star), R(0),
+ /* 1511 S> */ B(LdaConstant), U8(147),
+ /* 1513 E> */ B(Star), R(0),
+ /* 1521 S> */ B(LdaConstant), U8(148),
+ /* 1523 E> */ B(Star), R(0),
+ /* 1531 S> */ B(LdaConstant), U8(149),
+ /* 1533 E> */ B(Star), R(0),
+ /* 1541 S> */ B(LdaConstant), U8(150),
+ /* 1543 E> */ B(Star), R(0),
+ /* 1551 S> */ B(LdaConstant), U8(151),
+ /* 1553 E> */ B(Star), R(0),
+ /* 1561 S> */ B(LdaConstant), U8(152),
+ /* 1563 E> */ B(Star), R(0),
+ /* 1571 S> */ B(LdaConstant), U8(153),
+ /* 1573 E> */ B(Star), R(0),
+ /* 1581 S> */ B(LdaConstant), U8(154),
+ /* 1583 E> */ B(Star), R(0),
+ /* 1591 S> */ B(LdaConstant), U8(155),
+ /* 1593 E> */ B(Star), R(0),
+ /* 1601 S> */ B(LdaConstant), U8(156),
+ /* 1603 E> */ B(Star), R(0),
+ /* 1611 S> */ B(LdaConstant), U8(157),
+ /* 1613 E> */ B(Star), R(0),
+ /* 1621 S> */ B(LdaConstant), U8(158),
+ /* 1623 E> */ B(Star), R(0),
+ /* 1631 S> */ B(LdaConstant), U8(159),
+ /* 1633 E> */ B(Star), R(0),
+ /* 1641 S> */ B(LdaConstant), U8(160),
+ /* 1643 E> */ B(Star), R(0),
+ /* 1651 S> */ B(LdaConstant), U8(161),
+ /* 1653 E> */ B(Star), R(0),
+ /* 1661 S> */ B(LdaConstant), U8(162),
+ /* 1663 E> */ B(Star), R(0),
+ /* 1671 S> */ B(LdaConstant), U8(163),
+ /* 1673 E> */ B(Star), R(0),
+ /* 1681 S> */ B(LdaConstant), U8(164),
+ /* 1683 E> */ B(Star), R(0),
+ /* 1691 S> */ B(LdaConstant), U8(165),
+ /* 1693 E> */ B(Star), R(0),
+ /* 1701 S> */ B(LdaConstant), U8(166),
+ /* 1703 E> */ B(Star), R(0),
+ /* 1711 S> */ B(LdaConstant), U8(167),
+ /* 1713 E> */ B(Star), R(0),
+ /* 1721 S> */ B(LdaConstant), U8(168),
+ /* 1723 E> */ B(Star), R(0),
+ /* 1731 S> */ B(LdaConstant), U8(169),
+ /* 1733 E> */ B(Star), R(0),
+ /* 1741 S> */ B(LdaConstant), U8(170),
+ /* 1743 E> */ B(Star), R(0),
+ /* 1751 S> */ B(LdaConstant), U8(171),
+ /* 1753 E> */ B(Star), R(0),
+ /* 1761 S> */ B(LdaConstant), U8(172),
+ /* 1763 E> */ B(Star), R(0),
+ /* 1771 S> */ B(LdaConstant), U8(173),
+ /* 1773 E> */ B(Star), R(0),
+ /* 1781 S> */ B(LdaConstant), U8(174),
+ /* 1783 E> */ B(Star), R(0),
+ /* 1791 S> */ B(LdaConstant), U8(175),
+ /* 1793 E> */ B(Star), R(0),
+ /* 1801 S> */ B(LdaConstant), U8(176),
+ /* 1803 E> */ B(Star), R(0),
+ /* 1811 S> */ B(LdaConstant), U8(177),
+ /* 1813 E> */ B(Star), R(0),
+ /* 1821 S> */ B(LdaConstant), U8(178),
+ /* 1823 E> */ B(Star), R(0),
+ /* 1831 S> */ B(LdaConstant), U8(179),
+ /* 1833 E> */ B(Star), R(0),
+ /* 1841 S> */ B(LdaConstant), U8(180),
+ /* 1843 E> */ B(Star), R(0),
+ /* 1851 S> */ B(LdaConstant), U8(181),
+ /* 1853 E> */ B(Star), R(0),
+ /* 1861 S> */ B(LdaConstant), U8(182),
+ /* 1863 E> */ B(Star), R(0),
+ /* 1871 S> */ B(LdaConstant), U8(183),
+ /* 1873 E> */ B(Star), R(0),
+ /* 1881 S> */ B(LdaConstant), U8(184),
+ /* 1883 E> */ B(Star), R(0),
+ /* 1891 S> */ B(LdaConstant), U8(185),
+ /* 1893 E> */ B(Star), R(0),
+ /* 1901 S> */ B(LdaConstant), U8(186),
+ /* 1903 E> */ B(Star), R(0),
+ /* 1911 S> */ B(LdaConstant), U8(187),
+ /* 1913 E> */ B(Star), R(0),
+ /* 1921 S> */ B(LdaConstant), U8(188),
+ /* 1923 E> */ B(Star), R(0),
+ /* 1931 S> */ B(LdaConstant), U8(189),
+ /* 1933 E> */ B(Star), R(0),
+ /* 1941 S> */ B(LdaConstant), U8(190),
+ /* 1943 E> */ B(Star), R(0),
+ /* 1951 S> */ B(LdaConstant), U8(191),
+ /* 1953 E> */ B(Star), R(0),
+ /* 1961 S> */ B(LdaConstant), U8(192),
+ /* 1963 E> */ B(Star), R(0),
+ /* 1971 S> */ B(LdaConstant), U8(193),
+ /* 1973 E> */ B(Star), R(0),
+ /* 1981 S> */ B(LdaConstant), U8(194),
+ /* 1983 E> */ B(Star), R(0),
+ /* 1991 S> */ B(LdaConstant), U8(195),
+ /* 1993 E> */ B(Star), R(0),
+ /* 2001 S> */ B(LdaConstant), U8(196),
+ /* 2003 E> */ B(Star), R(0),
+ /* 2011 S> */ B(LdaConstant), U8(197),
+ /* 2013 E> */ B(Star), R(0),
+ /* 2021 S> */ B(LdaConstant), U8(198),
+ /* 2023 E> */ B(Star), R(0),
+ /* 2031 S> */ B(LdaConstant), U8(199),
+ /* 2033 E> */ B(Star), R(0),
+ /* 2041 S> */ B(LdaConstant), U8(200),
+ /* 2043 E> */ B(Star), R(0),
+ /* 2051 S> */ B(LdaConstant), U8(201),
+ /* 2053 E> */ B(Star), R(0),
+ /* 2061 S> */ B(LdaConstant), U8(202),
+ /* 2063 E> */ B(Star), R(0),
+ /* 2071 S> */ B(LdaConstant), U8(203),
+ /* 2073 E> */ B(Star), R(0),
+ /* 2081 S> */ B(LdaConstant), U8(204),
+ /* 2083 E> */ B(Star), R(0),
+ /* 2091 S> */ B(LdaConstant), U8(205),
+ /* 2093 E> */ B(Star), R(0),
+ /* 2101 S> */ B(LdaConstant), U8(206),
+ /* 2103 E> */ B(Star), R(0),
+ /* 2111 S> */ B(LdaConstant), U8(207),
+ /* 2113 E> */ B(Star), R(0),
+ /* 2121 S> */ B(LdaConstant), U8(208),
+ /* 2123 E> */ B(Star), R(0),
+ /* 2131 S> */ B(LdaConstant), U8(209),
+ /* 2133 E> */ B(Star), R(0),
+ /* 2141 S> */ B(LdaConstant), U8(210),
+ /* 2143 E> */ B(Star), R(0),
+ /* 2151 S> */ B(LdaConstant), U8(211),
+ /* 2153 E> */ B(Star), R(0),
+ /* 2161 S> */ B(LdaConstant), U8(212),
+ /* 2163 E> */ B(Star), R(0),
+ /* 2171 S> */ B(LdaConstant), U8(213),
+ /* 2173 E> */ B(Star), R(0),
+ /* 2181 S> */ B(LdaConstant), U8(214),
+ /* 2183 E> */ B(Star), R(0),
+ /* 2191 S> */ B(LdaConstant), U8(215),
+ /* 2193 E> */ B(Star), R(0),
+ /* 2201 S> */ B(LdaConstant), U8(216),
+ /* 2203 E> */ B(Star), R(0),
+ /* 2211 S> */ B(LdaConstant), U8(217),
+ /* 2213 E> */ B(Star), R(0),
+ /* 2221 S> */ B(LdaConstant), U8(218),
+ /* 2223 E> */ B(Star), R(0),
+ /* 2231 S> */ B(LdaConstant), U8(219),
+ /* 2233 E> */ B(Star), R(0),
+ /* 2241 S> */ B(LdaConstant), U8(220),
+ /* 2243 E> */ B(Star), R(0),
+ /* 2251 S> */ B(LdaConstant), U8(221),
+ /* 2253 E> */ B(Star), R(0),
+ /* 2261 S> */ B(LdaConstant), U8(222),
+ /* 2263 E> */ B(Star), R(0),
+ /* 2271 S> */ B(LdaConstant), U8(223),
+ /* 2273 E> */ B(Star), R(0),
+ /* 2281 S> */ B(LdaConstant), U8(224),
+ /* 2283 E> */ B(Star), R(0),
+ /* 2291 S> */ B(LdaConstant), U8(225),
+ /* 2293 E> */ B(Star), R(0),
+ /* 2301 S> */ B(LdaConstant), U8(226),
+ /* 2303 E> */ B(Star), R(0),
+ /* 2311 S> */ B(LdaConstant), U8(227),
+ /* 2313 E> */ B(Star), R(0),
+ /* 2321 S> */ B(LdaConstant), U8(228),
+ /* 2323 E> */ B(Star), R(0),
+ /* 2331 S> */ B(LdaConstant), U8(229),
+ /* 2333 E> */ B(Star), R(0),
+ /* 2341 S> */ B(LdaConstant), U8(230),
+ /* 2343 E> */ B(Star), R(0),
+ /* 2351 S> */ B(LdaConstant), U8(231),
+ /* 2353 E> */ B(Star), R(0),
+ /* 2361 S> */ B(LdaConstant), U8(232),
+ /* 2363 E> */ B(Star), R(0),
+ /* 2371 S> */ B(LdaConstant), U8(233),
+ /* 2373 E> */ B(Star), R(0),
+ /* 2381 S> */ B(LdaConstant), U8(234),
+ /* 2383 E> */ B(Star), R(0),
+ /* 2391 S> */ B(LdaConstant), U8(235),
+ /* 2393 E> */ B(Star), R(0),
+ /* 2401 S> */ B(LdaConstant), U8(236),
+ /* 2403 E> */ B(Star), R(0),
+ /* 2411 S> */ B(LdaConstant), U8(237),
+ /* 2413 E> */ B(Star), R(0),
+ /* 2421 S> */ B(LdaConstant), U8(238),
+ /* 2423 E> */ B(Star), R(0),
+ /* 2431 S> */ B(LdaConstant), U8(239),
+ /* 2433 E> */ B(Star), R(0),
+ /* 2441 S> */ B(LdaConstant), U8(240),
+ /* 2443 E> */ B(Star), R(0),
+ /* 2451 S> */ B(LdaConstant), U8(241),
+ /* 2453 E> */ B(Star), R(0),
+ /* 2461 S> */ B(LdaConstant), U8(242),
+ /* 2463 E> */ B(Star), R(0),
+ /* 2471 S> */ B(LdaConstant), U8(243),
+ /* 2473 E> */ B(Star), R(0),
+ /* 2481 S> */ B(LdaConstant), U8(244),
+ /* 2483 E> */ B(Star), R(0),
+ /* 2491 S> */ B(LdaConstant), U8(245),
+ /* 2493 E> */ B(Star), R(0),
+ /* 2501 S> */ B(LdaConstant), U8(246),
+ /* 2503 E> */ B(Star), R(0),
+ /* 2511 S> */ B(LdaConstant), U8(247),
+ /* 2513 E> */ B(Star), R(0),
+ /* 2521 S> */ B(LdaConstant), U8(248),
+ /* 2523 E> */ B(Star), R(0),
+ /* 2531 S> */ B(LdaConstant), U8(249),
+ /* 2533 E> */ B(Star), R(0),
+ /* 2541 S> */ B(LdaConstant), U8(250),
+ /* 2543 E> */ B(Star), R(0),
+ /* 2551 S> */ B(LdaConstant), U8(251),
+ /* 2553 E> */ B(Star), R(0),
+ /* 2561 S> */ B(LdaConstant), U8(252),
+ /* 2563 E> */ B(Star), R(0),
+ /* 2571 S> */ B(LdaConstant), U8(253),
+ /* 2573 E> */ B(Star), R(0),
+ /* 2581 S> */ B(LdaConstant), U8(254),
+ /* 2583 E> */ B(Star), R(0),
+ /* 2591 S> */ B(LdaConstant), U8(255),
+ /* 2593 E> */ B(Star), R(0),
+ /* 2601 S> */ B(Wide), B(CreateRegExpLiteral), U16(256), U16(0), U8(0),
+ /* 2616 S> */ B(Return),
]
constant pool: [
InstanceType::HEAP_NUMBER_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/RemoveRedundantLdar.golden b/test/cctest/interpreter/bytecode_expectations/RemoveRedundantLdar.golden
index e9283cd..b5ebec1 100644
--- a/test/cctest/interpreter/bytecode_expectations/RemoveRedundantLdar.golden
+++ b/test/cctest/interpreter/bytecode_expectations/RemoveRedundantLdar.golden
@@ -20,23 +20,23 @@
parameter count: 1
bytecode array length: 31
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Add), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(10),
- B(TestGreaterThan), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(4),
- B(Jump), U8(-21),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 45 S> */ B(LdaSmi), U8(1),
+ /* 45 E> */ B(Star), R(0),
+ /* 48 E> */ B(StackCheck),
+ /* 64 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ /* 78 E> */ B(Ldar), R(0),
+ B(Add), R(1),
+ /* 69 E> */ B(Star), R(0),
+ /* 86 S> */ B(Star), R(1),
+ B(LdaSmi), U8(10),
+ /* 95 E> */ B(TestGreaterThan), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 101 S> */ B(Jump), U8(4),
+ B(Jump), U8(-21),
+ /* 110 S> */ B(Ldar), R(0),
+ /* 123 S> */ B(Return),
]
constant pool: [
]
@@ -56,22 +56,22 @@
parameter count: 1
bytecode array length: 29
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Add), R(1),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(10),
- B(TestGreaterThan), R(1),
- B(JumpIfFalse), U8(4),
- B(Jump), U8(2),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 45 S> */ B(LdaSmi), U8(1),
+ /* 45 E> */ B(Star), R(0),
+ /* 48 E> */ B(StackCheck),
+ /* 55 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ /* 69 E> */ B(Ldar), R(0),
+ B(Add), R(1),
+ /* 60 E> */ B(Star), R(0),
+ /* 77 S> */ B(Star), R(1),
+ B(LdaSmi), U8(10),
+ /* 86 E> */ B(TestGreaterThan), R(1),
+ B(JumpIfFalse), U8(4),
+ /* 92 S> */ B(Jump), U8(2),
+ /* 118 S> */ B(Ldar), R(0),
+ /* 131 S> */ B(Return),
]
constant pool: [
]
@@ -88,14 +88,14 @@
parameter count: 1
bytecode array length: 14
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Star), R(1),
- B(Ldar), R(0),
- B(Add), R(1),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 45 S> */ B(LdaSmi), U8(1),
+ /* 45 E> */ B(Star), R(0),
+ /* 50 S> */ B(Star), R(1),
+ /* 64 E> */ B(Ldar), R(0),
+ B(Add), R(1),
+ /* 55 E> */ B(Star), R(0),
+ /* 85 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/StoreGlobal.golden b/test/cctest/interpreter/bytecode_expectations/StoreGlobal.golden
index 151c334..bddfe77 100644
--- a/test/cctest/interpreter/bytecode_expectations/StoreGlobal.golden
+++ b/test/cctest/interpreter/bytecode_expectations/StoreGlobal.golden
@@ -18,11 +18,11 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(2),
- B(StaGlobalSloppy), U8(0), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 21 E> */ B(StackCheck),
+ /* 26 S> */ B(LdaSmi), U8(2),
+ /* 28 E> */ B(StaGlobalSloppy), U8(0), U8(1),
+ B(LdaUndefined),
+ /* 33 S> */ B(Return),
]
constant pool: [
"a",
@@ -39,11 +39,11 @@
parameter count: 2
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(StaGlobalSloppy), U8(0), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 26 E> */ B(StackCheck),
+ /* 32 S> */ B(Ldar), R(arg0),
+ /* 34 E> */ B(StaGlobalSloppy), U8(0), U8(1),
+ B(LdaUndefined),
+ /* 39 S> */ B(Return),
]
constant pool: [
"a",
@@ -61,11 +61,11 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(2),
- B(StaGlobalStrict), U8(0), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 35 E> */ B(StackCheck),
+ /* 40 S> */ B(LdaSmi), U8(2),
+ /* 42 E> */ B(StaGlobalStrict), U8(0), U8(1),
+ B(LdaUndefined),
+ /* 47 S> */ B(Return),
]
constant pool: [
"a",
@@ -83,11 +83,11 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(2),
- B(StaGlobalSloppy), U8(0), U8(1),
- B(LdaUndefined),
- B(Return),
+ /* 17 E> */ B(StackCheck),
+ /* 22 S> */ B(LdaSmi), U8(2),
+ /* 24 E> */ B(StaGlobalSloppy), U8(0), U8(1),
+ B(LdaUndefined),
+ /* 29 S> */ B(Return),
]
constant pool: [
"a",
@@ -235,395 +235,395 @@
parameter count: 2
bytecode array length: 1035
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(1),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(3),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(5),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(7),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(9),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(11),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(13),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(15),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(17),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(19),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(21),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(23),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(25),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(27),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(29),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(31),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(33),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(35),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(37),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(39),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(41),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(43),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(45),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(47),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(49),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(51),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(53),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(55),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(57),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(59),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(61),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(63),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(65),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(67),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(69),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(71),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(73),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(75),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(77),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(79),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(81),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(83),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(85),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(87),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(89),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(91),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(93),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(95),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(97),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(99),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(101),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(103),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(105),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(107),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(109),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(111),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(113),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(115),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(117),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(119),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(121),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(123),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(125),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(127),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(129),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(131),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(133),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(135),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(137),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(139),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(141),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(143),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(145),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(147),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(149),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(151),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(153),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(155),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(157),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(159),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(161),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(163),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(165),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(167),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(169),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(171),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(173),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(175),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(177),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(179),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(181),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(183),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(185),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(187),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(189),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(191),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(193),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(195),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(197),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(199),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(201),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(203),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(205),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(207),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(209),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(211),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(213),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(215),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(217),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(219),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(221),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(223),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(225),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(227),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(229),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(231),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(233),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(235),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(237),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(239),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(241),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(243),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(245),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(247),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(249),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(251),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(253),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(255),
- B(LdaSmi), U8(2),
- B(Wide), B(StaGlobalSloppy), U16(1), U16(257),
- B(LdaUndefined),
- B(Return),
+ /* 17 E> */ B(StackCheck),
+ /* 25 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 26 E> */ B(LoadIC), R(0), U8(0), U8(1),
+ /* 35 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 36 E> */ B(LoadIC), R(0), U8(0), U8(3),
+ /* 45 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 46 E> */ B(LoadIC), R(0), U8(0), U8(5),
+ /* 55 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 56 E> */ B(LoadIC), R(0), U8(0), U8(7),
+ /* 65 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 66 E> */ B(LoadIC), R(0), U8(0), U8(9),
+ /* 75 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 76 E> */ B(LoadIC), R(0), U8(0), U8(11),
+ /* 85 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 86 E> */ B(LoadIC), R(0), U8(0), U8(13),
+ /* 95 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 96 E> */ B(LoadIC), R(0), U8(0), U8(15),
+ /* 105 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 106 E> */ B(LoadIC), R(0), U8(0), U8(17),
+ /* 115 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 116 E> */ B(LoadIC), R(0), U8(0), U8(19),
+ /* 125 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 126 E> */ B(LoadIC), R(0), U8(0), U8(21),
+ /* 135 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 136 E> */ B(LoadIC), R(0), U8(0), U8(23),
+ /* 145 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 146 E> */ B(LoadIC), R(0), U8(0), U8(25),
+ /* 155 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 156 E> */ B(LoadIC), R(0), U8(0), U8(27),
+ /* 165 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 166 E> */ B(LoadIC), R(0), U8(0), U8(29),
+ /* 175 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 176 E> */ B(LoadIC), R(0), U8(0), U8(31),
+ /* 185 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 186 E> */ B(LoadIC), R(0), U8(0), U8(33),
+ /* 195 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 196 E> */ B(LoadIC), R(0), U8(0), U8(35),
+ /* 205 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 206 E> */ B(LoadIC), R(0), U8(0), U8(37),
+ /* 215 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 216 E> */ B(LoadIC), R(0), U8(0), U8(39),
+ /* 225 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 226 E> */ B(LoadIC), R(0), U8(0), U8(41),
+ /* 235 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 236 E> */ B(LoadIC), R(0), U8(0), U8(43),
+ /* 245 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 246 E> */ B(LoadIC), R(0), U8(0), U8(45),
+ /* 255 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 256 E> */ B(LoadIC), R(0), U8(0), U8(47),
+ /* 265 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 266 E> */ B(LoadIC), R(0), U8(0), U8(49),
+ /* 275 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 276 E> */ B(LoadIC), R(0), U8(0), U8(51),
+ /* 285 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 286 E> */ B(LoadIC), R(0), U8(0), U8(53),
+ /* 295 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 296 E> */ B(LoadIC), R(0), U8(0), U8(55),
+ /* 305 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 306 E> */ B(LoadIC), R(0), U8(0), U8(57),
+ /* 315 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 316 E> */ B(LoadIC), R(0), U8(0), U8(59),
+ /* 325 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 326 E> */ B(LoadIC), R(0), U8(0), U8(61),
+ /* 335 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 336 E> */ B(LoadIC), R(0), U8(0), U8(63),
+ /* 345 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 346 E> */ B(LoadIC), R(0), U8(0), U8(65),
+ /* 355 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 356 E> */ B(LoadIC), R(0), U8(0), U8(67),
+ /* 365 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 366 E> */ B(LoadIC), R(0), U8(0), U8(69),
+ /* 375 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 376 E> */ B(LoadIC), R(0), U8(0), U8(71),
+ /* 385 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 386 E> */ B(LoadIC), R(0), U8(0), U8(73),
+ /* 395 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 396 E> */ B(LoadIC), R(0), U8(0), U8(75),
+ /* 405 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 406 E> */ B(LoadIC), R(0), U8(0), U8(77),
+ /* 415 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 416 E> */ B(LoadIC), R(0), U8(0), U8(79),
+ /* 425 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 426 E> */ B(LoadIC), R(0), U8(0), U8(81),
+ /* 435 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 436 E> */ B(LoadIC), R(0), U8(0), U8(83),
+ /* 445 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 446 E> */ B(LoadIC), R(0), U8(0), U8(85),
+ /* 455 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 456 E> */ B(LoadIC), R(0), U8(0), U8(87),
+ /* 465 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 466 E> */ B(LoadIC), R(0), U8(0), U8(89),
+ /* 475 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 476 E> */ B(LoadIC), R(0), U8(0), U8(91),
+ /* 485 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 486 E> */ B(LoadIC), R(0), U8(0), U8(93),
+ /* 495 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 496 E> */ B(LoadIC), R(0), U8(0), U8(95),
+ /* 505 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 506 E> */ B(LoadIC), R(0), U8(0), U8(97),
+ /* 515 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 516 E> */ B(LoadIC), R(0), U8(0), U8(99),
+ /* 525 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 526 E> */ B(LoadIC), R(0), U8(0), U8(101),
+ /* 535 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 536 E> */ B(LoadIC), R(0), U8(0), U8(103),
+ /* 545 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 546 E> */ B(LoadIC), R(0), U8(0), U8(105),
+ /* 555 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 556 E> */ B(LoadIC), R(0), U8(0), U8(107),
+ /* 565 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 566 E> */ B(LoadIC), R(0), U8(0), U8(109),
+ /* 575 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 576 E> */ B(LoadIC), R(0), U8(0), U8(111),
+ /* 585 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 586 E> */ B(LoadIC), R(0), U8(0), U8(113),
+ /* 595 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 596 E> */ B(LoadIC), R(0), U8(0), U8(115),
+ /* 605 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 606 E> */ B(LoadIC), R(0), U8(0), U8(117),
+ /* 615 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 616 E> */ B(LoadIC), R(0), U8(0), U8(119),
+ /* 625 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 626 E> */ B(LoadIC), R(0), U8(0), U8(121),
+ /* 635 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 636 E> */ B(LoadIC), R(0), U8(0), U8(123),
+ /* 645 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 646 E> */ B(LoadIC), R(0), U8(0), U8(125),
+ /* 655 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 656 E> */ B(LoadIC), R(0), U8(0), U8(127),
+ /* 665 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 666 E> */ B(LoadIC), R(0), U8(0), U8(129),
+ /* 675 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 676 E> */ B(LoadIC), R(0), U8(0), U8(131),
+ /* 685 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 686 E> */ B(LoadIC), R(0), U8(0), U8(133),
+ /* 695 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 696 E> */ B(LoadIC), R(0), U8(0), U8(135),
+ /* 705 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 706 E> */ B(LoadIC), R(0), U8(0), U8(137),
+ /* 715 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 716 E> */ B(LoadIC), R(0), U8(0), U8(139),
+ /* 725 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 726 E> */ B(LoadIC), R(0), U8(0), U8(141),
+ /* 735 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 736 E> */ B(LoadIC), R(0), U8(0), U8(143),
+ /* 745 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 746 E> */ B(LoadIC), R(0), U8(0), U8(145),
+ /* 755 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 756 E> */ B(LoadIC), R(0), U8(0), U8(147),
+ /* 765 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 766 E> */ B(LoadIC), R(0), U8(0), U8(149),
+ /* 775 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 776 E> */ B(LoadIC), R(0), U8(0), U8(151),
+ /* 785 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 786 E> */ B(LoadIC), R(0), U8(0), U8(153),
+ /* 795 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 796 E> */ B(LoadIC), R(0), U8(0), U8(155),
+ /* 805 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 806 E> */ B(LoadIC), R(0), U8(0), U8(157),
+ /* 815 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 816 E> */ B(LoadIC), R(0), U8(0), U8(159),
+ /* 825 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 826 E> */ B(LoadIC), R(0), U8(0), U8(161),
+ /* 835 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 836 E> */ B(LoadIC), R(0), U8(0), U8(163),
+ /* 845 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 846 E> */ B(LoadIC), R(0), U8(0), U8(165),
+ /* 855 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 856 E> */ B(LoadIC), R(0), U8(0), U8(167),
+ /* 865 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 866 E> */ B(LoadIC), R(0), U8(0), U8(169),
+ /* 875 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 876 E> */ B(LoadIC), R(0), U8(0), U8(171),
+ /* 885 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 886 E> */ B(LoadIC), R(0), U8(0), U8(173),
+ /* 895 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 896 E> */ B(LoadIC), R(0), U8(0), U8(175),
+ /* 905 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 906 E> */ B(LoadIC), R(0), U8(0), U8(177),
+ /* 915 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 916 E> */ B(LoadIC), R(0), U8(0), U8(179),
+ /* 925 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 926 E> */ B(LoadIC), R(0), U8(0), U8(181),
+ /* 935 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 936 E> */ B(LoadIC), R(0), U8(0), U8(183),
+ /* 945 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 946 E> */ B(LoadIC), R(0), U8(0), U8(185),
+ /* 955 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 956 E> */ B(LoadIC), R(0), U8(0), U8(187),
+ /* 965 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 966 E> */ B(LoadIC), R(0), U8(0), U8(189),
+ /* 975 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 976 E> */ B(LoadIC), R(0), U8(0), U8(191),
+ /* 985 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 986 E> */ B(LoadIC), R(0), U8(0), U8(193),
+ /* 995 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 996 E> */ B(LoadIC), R(0), U8(0), U8(195),
+ /* 1005 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1006 E> */ B(LoadIC), R(0), U8(0), U8(197),
+ /* 1015 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1016 E> */ B(LoadIC), R(0), U8(0), U8(199),
+ /* 1025 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1026 E> */ B(LoadIC), R(0), U8(0), U8(201),
+ /* 1035 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1036 E> */ B(LoadIC), R(0), U8(0), U8(203),
+ /* 1045 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1046 E> */ B(LoadIC), R(0), U8(0), U8(205),
+ /* 1055 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1056 E> */ B(LoadIC), R(0), U8(0), U8(207),
+ /* 1065 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1066 E> */ B(LoadIC), R(0), U8(0), U8(209),
+ /* 1075 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1076 E> */ B(LoadIC), R(0), U8(0), U8(211),
+ /* 1085 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1086 E> */ B(LoadIC), R(0), U8(0), U8(213),
+ /* 1095 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1096 E> */ B(LoadIC), R(0), U8(0), U8(215),
+ /* 1105 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1106 E> */ B(LoadIC), R(0), U8(0), U8(217),
+ /* 1115 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1116 E> */ B(LoadIC), R(0), U8(0), U8(219),
+ /* 1125 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1126 E> */ B(LoadIC), R(0), U8(0), U8(221),
+ /* 1135 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1136 E> */ B(LoadIC), R(0), U8(0), U8(223),
+ /* 1145 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1146 E> */ B(LoadIC), R(0), U8(0), U8(225),
+ /* 1155 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1156 E> */ B(LoadIC), R(0), U8(0), U8(227),
+ /* 1165 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1166 E> */ B(LoadIC), R(0), U8(0), U8(229),
+ /* 1175 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1176 E> */ B(LoadIC), R(0), U8(0), U8(231),
+ /* 1185 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1186 E> */ B(LoadIC), R(0), U8(0), U8(233),
+ /* 1195 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1196 E> */ B(LoadIC), R(0), U8(0), U8(235),
+ /* 1205 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1206 E> */ B(LoadIC), R(0), U8(0), U8(237),
+ /* 1215 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1216 E> */ B(LoadIC), R(0), U8(0), U8(239),
+ /* 1225 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1226 E> */ B(LoadIC), R(0), U8(0), U8(241),
+ /* 1235 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1236 E> */ B(LoadIC), R(0), U8(0), U8(243),
+ /* 1245 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1246 E> */ B(LoadIC), R(0), U8(0), U8(245),
+ /* 1255 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1256 E> */ B(LoadIC), R(0), U8(0), U8(247),
+ /* 1265 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1266 E> */ B(LoadIC), R(0), U8(0), U8(249),
+ /* 1275 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1276 E> */ B(LoadIC), R(0), U8(0), U8(251),
+ /* 1285 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1286 E> */ B(LoadIC), R(0), U8(0), U8(253),
+ /* 1295 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1296 E> */ B(LoadIC), R(0), U8(0), U8(255),
+ /* 1305 S> */ B(LdaSmi), U8(2),
+ /* 1307 E> */ B(Wide), B(StaGlobalSloppy), U16(1), U16(257),
+ B(LdaUndefined),
+ /* 1312 S> */ B(Return),
]
constant pool: [
"name",
@@ -773,395 +773,395 @@
parameter count: 2
bytecode array length: 1035
bytecodes: [
- B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(1),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(3),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(5),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(7),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(9),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(11),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(13),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(15),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(17),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(19),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(21),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(23),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(25),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(27),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(29),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(31),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(33),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(35),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(37),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(39),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(41),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(43),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(45),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(47),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(49),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(51),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(53),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(55),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(57),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(59),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(61),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(63),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(65),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(67),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(69),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(71),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(73),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(75),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(77),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(79),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(81),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(83),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(85),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(87),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(89),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(91),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(93),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(95),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(97),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(99),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(101),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(103),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(105),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(107),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(109),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(111),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(113),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(115),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(117),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(119),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(121),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(123),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(125),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(127),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(129),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(131),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(133),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(135),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(137),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(139),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(141),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(143),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(145),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(147),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(149),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(151),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(153),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(155),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(157),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(159),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(161),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(163),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(165),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(167),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(169),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(171),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(173),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(175),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(177),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(179),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(181),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(183),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(185),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(187),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(189),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(191),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(193),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(195),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(197),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(199),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(201),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(203),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(205),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(207),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(209),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(211),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(213),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(215),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(217),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(219),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(221),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(223),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(225),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(227),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(229),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(231),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(233),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(235),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(237),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(239),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(241),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(243),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(245),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(247),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(249),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(251),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(253),
- B(Ldar), R(arg0),
- B(Star), R(0),
- B(LoadIC), R(0), U8(0), U8(255),
- B(LdaSmi), U8(2),
- B(Wide), B(StaGlobalStrict), U16(1), U16(257),
- B(LdaUndefined),
- B(Return),
+ /* 17 E> */ B(StackCheck),
+ /* 41 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 42 E> */ B(LoadIC), R(0), U8(0), U8(1),
+ /* 51 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 52 E> */ B(LoadIC), R(0), U8(0), U8(3),
+ /* 61 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 62 E> */ B(LoadIC), R(0), U8(0), U8(5),
+ /* 71 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 72 E> */ B(LoadIC), R(0), U8(0), U8(7),
+ /* 81 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 82 E> */ B(LoadIC), R(0), U8(0), U8(9),
+ /* 91 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 92 E> */ B(LoadIC), R(0), U8(0), U8(11),
+ /* 101 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 102 E> */ B(LoadIC), R(0), U8(0), U8(13),
+ /* 111 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 112 E> */ B(LoadIC), R(0), U8(0), U8(15),
+ /* 121 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 122 E> */ B(LoadIC), R(0), U8(0), U8(17),
+ /* 131 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 132 E> */ B(LoadIC), R(0), U8(0), U8(19),
+ /* 141 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 142 E> */ B(LoadIC), R(0), U8(0), U8(21),
+ /* 151 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 152 E> */ B(LoadIC), R(0), U8(0), U8(23),
+ /* 161 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 162 E> */ B(LoadIC), R(0), U8(0), U8(25),
+ /* 171 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 172 E> */ B(LoadIC), R(0), U8(0), U8(27),
+ /* 181 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 182 E> */ B(LoadIC), R(0), U8(0), U8(29),
+ /* 191 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 192 E> */ B(LoadIC), R(0), U8(0), U8(31),
+ /* 201 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 202 E> */ B(LoadIC), R(0), U8(0), U8(33),
+ /* 211 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 212 E> */ B(LoadIC), R(0), U8(0), U8(35),
+ /* 221 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 222 E> */ B(LoadIC), R(0), U8(0), U8(37),
+ /* 231 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 232 E> */ B(LoadIC), R(0), U8(0), U8(39),
+ /* 241 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 242 E> */ B(LoadIC), R(0), U8(0), U8(41),
+ /* 251 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 252 E> */ B(LoadIC), R(0), U8(0), U8(43),
+ /* 261 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 262 E> */ B(LoadIC), R(0), U8(0), U8(45),
+ /* 271 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 272 E> */ B(LoadIC), R(0), U8(0), U8(47),
+ /* 281 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 282 E> */ B(LoadIC), R(0), U8(0), U8(49),
+ /* 291 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 292 E> */ B(LoadIC), R(0), U8(0), U8(51),
+ /* 301 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 302 E> */ B(LoadIC), R(0), U8(0), U8(53),
+ /* 311 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 312 E> */ B(LoadIC), R(0), U8(0), U8(55),
+ /* 321 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 322 E> */ B(LoadIC), R(0), U8(0), U8(57),
+ /* 331 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 332 E> */ B(LoadIC), R(0), U8(0), U8(59),
+ /* 341 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 342 E> */ B(LoadIC), R(0), U8(0), U8(61),
+ /* 351 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 352 E> */ B(LoadIC), R(0), U8(0), U8(63),
+ /* 361 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 362 E> */ B(LoadIC), R(0), U8(0), U8(65),
+ /* 371 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 372 E> */ B(LoadIC), R(0), U8(0), U8(67),
+ /* 381 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 382 E> */ B(LoadIC), R(0), U8(0), U8(69),
+ /* 391 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 392 E> */ B(LoadIC), R(0), U8(0), U8(71),
+ /* 401 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 402 E> */ B(LoadIC), R(0), U8(0), U8(73),
+ /* 411 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 412 E> */ B(LoadIC), R(0), U8(0), U8(75),
+ /* 421 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 422 E> */ B(LoadIC), R(0), U8(0), U8(77),
+ /* 431 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 432 E> */ B(LoadIC), R(0), U8(0), U8(79),
+ /* 441 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 442 E> */ B(LoadIC), R(0), U8(0), U8(81),
+ /* 451 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 452 E> */ B(LoadIC), R(0), U8(0), U8(83),
+ /* 461 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 462 E> */ B(LoadIC), R(0), U8(0), U8(85),
+ /* 471 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 472 E> */ B(LoadIC), R(0), U8(0), U8(87),
+ /* 481 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 482 E> */ B(LoadIC), R(0), U8(0), U8(89),
+ /* 491 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 492 E> */ B(LoadIC), R(0), U8(0), U8(91),
+ /* 501 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 502 E> */ B(LoadIC), R(0), U8(0), U8(93),
+ /* 511 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 512 E> */ B(LoadIC), R(0), U8(0), U8(95),
+ /* 521 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 522 E> */ B(LoadIC), R(0), U8(0), U8(97),
+ /* 531 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 532 E> */ B(LoadIC), R(0), U8(0), U8(99),
+ /* 541 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 542 E> */ B(LoadIC), R(0), U8(0), U8(101),
+ /* 551 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 552 E> */ B(LoadIC), R(0), U8(0), U8(103),
+ /* 561 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 562 E> */ B(LoadIC), R(0), U8(0), U8(105),
+ /* 571 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 572 E> */ B(LoadIC), R(0), U8(0), U8(107),
+ /* 581 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 582 E> */ B(LoadIC), R(0), U8(0), U8(109),
+ /* 591 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 592 E> */ B(LoadIC), R(0), U8(0), U8(111),
+ /* 601 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 602 E> */ B(LoadIC), R(0), U8(0), U8(113),
+ /* 611 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 612 E> */ B(LoadIC), R(0), U8(0), U8(115),
+ /* 621 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 622 E> */ B(LoadIC), R(0), U8(0), U8(117),
+ /* 631 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 632 E> */ B(LoadIC), R(0), U8(0), U8(119),
+ /* 641 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 642 E> */ B(LoadIC), R(0), U8(0), U8(121),
+ /* 651 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 652 E> */ B(LoadIC), R(0), U8(0), U8(123),
+ /* 661 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 662 E> */ B(LoadIC), R(0), U8(0), U8(125),
+ /* 671 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 672 E> */ B(LoadIC), R(0), U8(0), U8(127),
+ /* 681 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 682 E> */ B(LoadIC), R(0), U8(0), U8(129),
+ /* 691 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 692 E> */ B(LoadIC), R(0), U8(0), U8(131),
+ /* 701 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 702 E> */ B(LoadIC), R(0), U8(0), U8(133),
+ /* 711 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 712 E> */ B(LoadIC), R(0), U8(0), U8(135),
+ /* 721 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 722 E> */ B(LoadIC), R(0), U8(0), U8(137),
+ /* 731 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 732 E> */ B(LoadIC), R(0), U8(0), U8(139),
+ /* 741 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 742 E> */ B(LoadIC), R(0), U8(0), U8(141),
+ /* 751 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 752 E> */ B(LoadIC), R(0), U8(0), U8(143),
+ /* 761 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 762 E> */ B(LoadIC), R(0), U8(0), U8(145),
+ /* 771 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 772 E> */ B(LoadIC), R(0), U8(0), U8(147),
+ /* 781 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 782 E> */ B(LoadIC), R(0), U8(0), U8(149),
+ /* 791 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 792 E> */ B(LoadIC), R(0), U8(0), U8(151),
+ /* 801 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 802 E> */ B(LoadIC), R(0), U8(0), U8(153),
+ /* 811 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 812 E> */ B(LoadIC), R(0), U8(0), U8(155),
+ /* 821 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 822 E> */ B(LoadIC), R(0), U8(0), U8(157),
+ /* 831 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 832 E> */ B(LoadIC), R(0), U8(0), U8(159),
+ /* 841 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 842 E> */ B(LoadIC), R(0), U8(0), U8(161),
+ /* 851 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 852 E> */ B(LoadIC), R(0), U8(0), U8(163),
+ /* 861 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 862 E> */ B(LoadIC), R(0), U8(0), U8(165),
+ /* 871 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 872 E> */ B(LoadIC), R(0), U8(0), U8(167),
+ /* 881 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 882 E> */ B(LoadIC), R(0), U8(0), U8(169),
+ /* 891 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 892 E> */ B(LoadIC), R(0), U8(0), U8(171),
+ /* 901 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 902 E> */ B(LoadIC), R(0), U8(0), U8(173),
+ /* 911 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 912 E> */ B(LoadIC), R(0), U8(0), U8(175),
+ /* 921 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 922 E> */ B(LoadIC), R(0), U8(0), U8(177),
+ /* 931 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 932 E> */ B(LoadIC), R(0), U8(0), U8(179),
+ /* 941 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 942 E> */ B(LoadIC), R(0), U8(0), U8(181),
+ /* 951 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 952 E> */ B(LoadIC), R(0), U8(0), U8(183),
+ /* 961 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 962 E> */ B(LoadIC), R(0), U8(0), U8(185),
+ /* 971 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 972 E> */ B(LoadIC), R(0), U8(0), U8(187),
+ /* 981 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 982 E> */ B(LoadIC), R(0), U8(0), U8(189),
+ /* 991 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 992 E> */ B(LoadIC), R(0), U8(0), U8(191),
+ /* 1001 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1002 E> */ B(LoadIC), R(0), U8(0), U8(193),
+ /* 1011 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1012 E> */ B(LoadIC), R(0), U8(0), U8(195),
+ /* 1021 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1022 E> */ B(LoadIC), R(0), U8(0), U8(197),
+ /* 1031 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1032 E> */ B(LoadIC), R(0), U8(0), U8(199),
+ /* 1041 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1042 E> */ B(LoadIC), R(0), U8(0), U8(201),
+ /* 1051 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1052 E> */ B(LoadIC), R(0), U8(0), U8(203),
+ /* 1061 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1062 E> */ B(LoadIC), R(0), U8(0), U8(205),
+ /* 1071 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1072 E> */ B(LoadIC), R(0), U8(0), U8(207),
+ /* 1081 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1082 E> */ B(LoadIC), R(0), U8(0), U8(209),
+ /* 1091 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1092 E> */ B(LoadIC), R(0), U8(0), U8(211),
+ /* 1101 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1102 E> */ B(LoadIC), R(0), U8(0), U8(213),
+ /* 1111 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1112 E> */ B(LoadIC), R(0), U8(0), U8(215),
+ /* 1121 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1122 E> */ B(LoadIC), R(0), U8(0), U8(217),
+ /* 1131 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1132 E> */ B(LoadIC), R(0), U8(0), U8(219),
+ /* 1141 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1142 E> */ B(LoadIC), R(0), U8(0), U8(221),
+ /* 1151 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1152 E> */ B(LoadIC), R(0), U8(0), U8(223),
+ /* 1161 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1162 E> */ B(LoadIC), R(0), U8(0), U8(225),
+ /* 1171 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1172 E> */ B(LoadIC), R(0), U8(0), U8(227),
+ /* 1181 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1182 E> */ B(LoadIC), R(0), U8(0), U8(229),
+ /* 1191 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1192 E> */ B(LoadIC), R(0), U8(0), U8(231),
+ /* 1201 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1202 E> */ B(LoadIC), R(0), U8(0), U8(233),
+ /* 1211 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1212 E> */ B(LoadIC), R(0), U8(0), U8(235),
+ /* 1221 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1222 E> */ B(LoadIC), R(0), U8(0), U8(237),
+ /* 1231 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1232 E> */ B(LoadIC), R(0), U8(0), U8(239),
+ /* 1241 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1242 E> */ B(LoadIC), R(0), U8(0), U8(241),
+ /* 1251 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1252 E> */ B(LoadIC), R(0), U8(0), U8(243),
+ /* 1261 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1262 E> */ B(LoadIC), R(0), U8(0), U8(245),
+ /* 1271 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1272 E> */ B(LoadIC), R(0), U8(0), U8(247),
+ /* 1281 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1282 E> */ B(LoadIC), R(0), U8(0), U8(249),
+ /* 1291 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1292 E> */ B(LoadIC), R(0), U8(0), U8(251),
+ /* 1301 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1302 E> */ B(LoadIC), R(0), U8(0), U8(253),
+ /* 1311 S> */ B(Ldar), R(arg0),
+ B(Star), R(0),
+ /* 1312 E> */ B(LoadIC), R(0), U8(0), U8(255),
+ /* 1321 S> */ B(LdaSmi), U8(2),
+ /* 1323 E> */ B(Wide), B(StaGlobalStrict), U16(1), U16(257),
+ B(LdaUndefined),
+ /* 1328 S> */ B(Return),
]
constant pool: [
"name",
diff --git a/test/cctest/interpreter/bytecode_expectations/StringConstants.golden b/test/cctest/interpreter/bytecode_expectations/StringConstants.golden
index 9cf212c..a35df08 100644
--- a/test/cctest/interpreter/bytecode_expectations/StringConstants.golden
+++ b/test/cctest/interpreter/bytecode_expectations/StringConstants.golden
@@ -15,9 +15,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaConstant), U8(0),
+ /* 61 S> */ B(Return),
]
constant pool: [
"This is a string",
@@ -33,11 +33,11 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(0),
+ /* 58 S> */ B(LdaConstant), U8(1),
+ /* 82 S> */ B(Return),
]
constant pool: [
"First string",
@@ -54,11 +54,11 @@
parameter count: 1
bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Star), R(0),
- B(LdaConstant), U8(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaConstant), U8(0),
+ /* 42 E> */ B(Star), R(0),
+ /* 57 S> */ B(LdaConstant), U8(0),
+ /* 79 S> */ B(Return),
]
constant pool: [
"Same string",
diff --git a/test/cctest/interpreter/bytecode_expectations/Switch.golden b/test/cctest/interpreter/bytecode_expectations/Switch.golden
index c908959..c252140 100644
--- a/test/cctest/interpreter/bytecode_expectations/Switch.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Switch.golden
@@ -19,24 +19,24 @@
parameter count: 1
bytecode array length: 31
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(10),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(7),
- B(Jump), U8(8),
- B(LdaSmi), U8(2),
- B(Return),
- B(LdaSmi), U8(3),
- B(Return),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(1),
+ /* 52 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(10),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(7),
+ B(Jump), U8(8),
+ /* 66 S> */ B(LdaSmi), U8(2),
+ /* 97 S> */ B(Return),
+ /* 85 S> */ B(LdaSmi), U8(3),
+ /* 97 S> */ B(Return),
+ B(LdaUndefined),
+ /* 97 S> */ B(Return),
]
constant pool: [
]
@@ -55,26 +55,26 @@
parameter count: 1
bytecode array length: 37
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(10),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(10),
- B(Jump), U8(14),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(Jump), U8(8),
- B(LdaSmi), U8(3),
- B(Star), R(1),
- B(Jump), U8(2),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(1),
+ /* 52 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(10),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(10),
+ B(Jump), U8(14),
+ /* 66 S> */ B(LdaSmi), U8(2),
+ /* 68 E> */ B(Star), R(1),
+ /* 73 S> */ B(Jump), U8(8),
+ /* 89 S> */ B(LdaSmi), U8(3),
+ /* 91 E> */ B(Star), R(1),
+ /* 96 S> */ B(Jump), U8(2),
+ B(LdaUndefined),
+ /* 105 S> */ B(Return),
]
constant pool: [
]
@@ -93,25 +93,25 @@
parameter count: 1
bytecode array length: 35
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(10),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(8),
- B(Jump), U8(12),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Star), R(1),
- B(Jump), U8(2),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(1),
+ /* 52 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(10),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(8),
+ B(Jump), U8(12),
+ /* 66 S> */ B(LdaSmi), U8(2),
+ /* 68 E> */ B(Star), R(1),
+ /* 98 S> */ B(LdaSmi), U8(3),
+ /* 100 E> */ B(Star), R(1),
+ /* 105 S> */ B(Jump), U8(2),
+ B(LdaUndefined),
+ /* 114 S> */ B(Return),
]
constant pool: [
]
@@ -131,25 +131,25 @@
parameter count: 1
bytecode array length: 35
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(10),
- B(LdaSmi), U8(3),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(6),
- B(Jump), U8(6),
- B(Jump), U8(10),
- B(Jump), U8(8),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Jump), U8(2),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(1),
+ /* 52 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(2),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(10),
+ B(LdaSmi), U8(3),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(6),
+ B(Jump), U8(6),
+ /* 66 S> */ B(Jump), U8(10),
+ /* 82 S> */ B(Jump), U8(8),
+ /* 99 S> */ B(LdaSmi), U8(1),
+ /* 101 E> */ B(Star), R(1),
+ /* 106 S> */ B(Jump), U8(2),
+ B(LdaUndefined),
+ /* 115 S> */ B(Return),
]
constant pool: [
]
@@ -169,30 +169,30 @@
parameter count: 1
bytecode array length: 44
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(TypeOf),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(10),
- B(LdaSmi), U8(3),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(10),
- B(Jump), U8(14),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Jump), U8(14),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(Jump), U8(8),
- B(LdaSmi), U8(3),
- B(Star), R(1),
- B(Jump), U8(2),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(1),
+ B(TypeOf),
+ /* 52 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(2),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(10),
+ B(LdaSmi), U8(3),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(10),
+ B(Jump), U8(14),
+ /* 74 S> */ B(LdaSmi), U8(1),
+ /* 76 E> */ B(Star), R(1),
+ /* 81 S> */ B(Jump), U8(14),
+ /* 97 S> */ B(LdaSmi), U8(2),
+ /* 99 E> */ B(Star), R(1),
+ /* 104 S> */ B(Jump), U8(8),
+ /* 121 S> */ B(LdaSmi), U8(3),
+ /* 123 E> */ B(Star), R(1),
+ /* 128 S> */ B(Jump), U8(2),
+ B(LdaUndefined),
+ /* 137 S> */ B(Return),
]
constant pool: [
]
@@ -211,24 +211,24 @@
parameter count: 1
bytecode array length: 32
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(2),
- B(Ldar), R(1),
- B(TypeOf),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(4),
- B(Jump), U8(8),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Jump), U8(8),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(Jump), U8(2),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(1),
+ /* 52 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(2),
+ B(Ldar), R(1),
+ B(TypeOf),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(4),
+ B(Jump), U8(8),
+ /* 74 S> */ B(LdaSmi), U8(1),
+ /* 76 E> */ B(Star), R(1),
+ /* 81 S> */ B(Jump), U8(8),
+ /* 98 S> */ B(LdaSmi), U8(2),
+ /* 100 E> */ B(Star), R(1),
+ /* 105 S> */ B(Jump), U8(2),
+ B(LdaUndefined),
+ /* 114 S> */ B(Return),
]
constant pool: [
]
@@ -314,152 +314,152 @@
parameter count: 1
bytecode array length: 289
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(1),
- B(Star), R(0),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(10),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(2),
- B(JumpIfTrueConstant), U8(0),
- B(JumpConstant), U8(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(1),
- B(Jump), U8(8),
- B(LdaSmi), U8(3),
- B(Star), R(1),
- B(Jump), U8(2),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(1),
+ /* 52 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(2),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(10),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrueConstant), U8(0),
+ B(JumpConstant), U8(1),
+ /* 68 S> */ B(LdaSmi), U8(2),
+ /* 70 E> */ B(Star), R(1),
+ /* 77 S> */ B(LdaSmi), U8(2),
+ /* 79 E> */ B(Star), R(1),
+ /* 86 S> */ B(LdaSmi), U8(2),
+ /* 88 E> */ B(Star), R(1),
+ /* 95 S> */ B(LdaSmi), U8(2),
+ /* 97 E> */ B(Star), R(1),
+ /* 104 S> */ B(LdaSmi), U8(2),
+ /* 106 E> */ B(Star), R(1),
+ /* 113 S> */ B(LdaSmi), U8(2),
+ /* 115 E> */ B(Star), R(1),
+ /* 122 S> */ B(LdaSmi), U8(2),
+ /* 124 E> */ B(Star), R(1),
+ /* 131 S> */ B(LdaSmi), U8(2),
+ /* 133 E> */ B(Star), R(1),
+ /* 140 S> */ B(LdaSmi), U8(2),
+ /* 142 E> */ B(Star), R(1),
+ /* 149 S> */ B(LdaSmi), U8(2),
+ /* 151 E> */ B(Star), R(1),
+ /* 158 S> */ B(LdaSmi), U8(2),
+ /* 160 E> */ B(Star), R(1),
+ /* 167 S> */ B(LdaSmi), U8(2),
+ /* 169 E> */ B(Star), R(1),
+ /* 176 S> */ B(LdaSmi), U8(2),
+ /* 178 E> */ B(Star), R(1),
+ /* 185 S> */ B(LdaSmi), U8(2),
+ /* 187 E> */ B(Star), R(1),
+ /* 194 S> */ B(LdaSmi), U8(2),
+ /* 196 E> */ B(Star), R(1),
+ /* 203 S> */ B(LdaSmi), U8(2),
+ /* 205 E> */ B(Star), R(1),
+ /* 212 S> */ B(LdaSmi), U8(2),
+ /* 214 E> */ B(Star), R(1),
+ /* 221 S> */ B(LdaSmi), U8(2),
+ /* 223 E> */ B(Star), R(1),
+ /* 230 S> */ B(LdaSmi), U8(2),
+ /* 232 E> */ B(Star), R(1),
+ /* 239 S> */ B(LdaSmi), U8(2),
+ /* 241 E> */ B(Star), R(1),
+ /* 248 S> */ B(LdaSmi), U8(2),
+ /* 250 E> */ B(Star), R(1),
+ /* 257 S> */ B(LdaSmi), U8(2),
+ /* 259 E> */ B(Star), R(1),
+ /* 266 S> */ B(LdaSmi), U8(2),
+ /* 268 E> */ B(Star), R(1),
+ /* 275 S> */ B(LdaSmi), U8(2),
+ /* 277 E> */ B(Star), R(1),
+ /* 284 S> */ B(LdaSmi), U8(2),
+ /* 286 E> */ B(Star), R(1),
+ /* 293 S> */ B(LdaSmi), U8(2),
+ /* 295 E> */ B(Star), R(1),
+ /* 302 S> */ B(LdaSmi), U8(2),
+ /* 304 E> */ B(Star), R(1),
+ /* 311 S> */ B(LdaSmi), U8(2),
+ /* 313 E> */ B(Star), R(1),
+ /* 320 S> */ B(LdaSmi), U8(2),
+ /* 322 E> */ B(Star), R(1),
+ /* 329 S> */ B(LdaSmi), U8(2),
+ /* 331 E> */ B(Star), R(1),
+ /* 338 S> */ B(LdaSmi), U8(2),
+ /* 340 E> */ B(Star), R(1),
+ /* 347 S> */ B(LdaSmi), U8(2),
+ /* 349 E> */ B(Star), R(1),
+ /* 356 S> */ B(LdaSmi), U8(2),
+ /* 358 E> */ B(Star), R(1),
+ /* 365 S> */ B(LdaSmi), U8(2),
+ /* 367 E> */ B(Star), R(1),
+ /* 374 S> */ B(LdaSmi), U8(2),
+ /* 376 E> */ B(Star), R(1),
+ /* 383 S> */ B(LdaSmi), U8(2),
+ /* 385 E> */ B(Star), R(1),
+ /* 392 S> */ B(LdaSmi), U8(2),
+ /* 394 E> */ B(Star), R(1),
+ /* 401 S> */ B(LdaSmi), U8(2),
+ /* 403 E> */ B(Star), R(1),
+ /* 410 S> */ B(LdaSmi), U8(2),
+ /* 412 E> */ B(Star), R(1),
+ /* 419 S> */ B(LdaSmi), U8(2),
+ /* 421 E> */ B(Star), R(1),
+ /* 428 S> */ B(LdaSmi), U8(2),
+ /* 430 E> */ B(Star), R(1),
+ /* 437 S> */ B(LdaSmi), U8(2),
+ /* 439 E> */ B(Star), R(1),
+ /* 446 S> */ B(LdaSmi), U8(2),
+ /* 448 E> */ B(Star), R(1),
+ /* 455 S> */ B(LdaSmi), U8(2),
+ /* 457 E> */ B(Star), R(1),
+ /* 464 S> */ B(LdaSmi), U8(2),
+ /* 466 E> */ B(Star), R(1),
+ /* 473 S> */ B(LdaSmi), U8(2),
+ /* 475 E> */ B(Star), R(1),
+ /* 482 S> */ B(LdaSmi), U8(2),
+ /* 484 E> */ B(Star), R(1),
+ /* 491 S> */ B(LdaSmi), U8(2),
+ /* 493 E> */ B(Star), R(1),
+ /* 500 S> */ B(LdaSmi), U8(2),
+ /* 502 E> */ B(Star), R(1),
+ /* 509 S> */ B(LdaSmi), U8(2),
+ /* 511 E> */ B(Star), R(1),
+ /* 518 S> */ B(LdaSmi), U8(2),
+ /* 520 E> */ B(Star), R(1),
+ /* 527 S> */ B(LdaSmi), U8(2),
+ /* 529 E> */ B(Star), R(1),
+ /* 536 S> */ B(LdaSmi), U8(2),
+ /* 538 E> */ B(Star), R(1),
+ /* 545 S> */ B(LdaSmi), U8(2),
+ /* 547 E> */ B(Star), R(1),
+ /* 554 S> */ B(LdaSmi), U8(2),
+ /* 556 E> */ B(Star), R(1),
+ /* 563 S> */ B(LdaSmi), U8(2),
+ /* 565 E> */ B(Star), R(1),
+ /* 572 S> */ B(LdaSmi), U8(2),
+ /* 574 E> */ B(Star), R(1),
+ /* 581 S> */ B(LdaSmi), U8(2),
+ /* 583 E> */ B(Star), R(1),
+ /* 590 S> */ B(LdaSmi), U8(2),
+ /* 592 E> */ B(Star), R(1),
+ /* 599 S> */ B(LdaSmi), U8(2),
+ /* 601 E> */ B(Star), R(1),
+ /* 608 S> */ B(LdaSmi), U8(2),
+ /* 610 E> */ B(Star), R(1),
+ /* 617 S> */ B(LdaSmi), U8(2),
+ /* 619 E> */ B(Star), R(1),
+ /* 626 S> */ B(LdaSmi), U8(2),
+ /* 628 E> */ B(Star), R(1),
+ /* 635 S> */ B(LdaSmi), U8(2),
+ /* 637 E> */ B(Star), R(1),
+ /* 644 S> */ B(Jump), U8(8),
+ /* 662 S> */ B(LdaSmi), U8(3),
+ /* 664 E> */ B(Star), R(1),
+ /* 671 S> */ B(Jump), U8(2),
+ B(LdaUndefined),
+ /* 680 S> */ B(Return),
]
constant pool: [
262,
@@ -484,38 +484,38 @@
parameter count: 1
bytecode array length: 61
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(2),
- B(Star), R(0),
- B(Star), R(3),
- B(LdaSmi), U8(1),
- B(TestEqualStrict), R(3),
- B(JumpIfTrue), U8(10),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(3),
- B(JumpIfTrue), U8(36),
- B(Jump), U8(38),
- B(Ldar), R(2),
- B(Star), R(4),
- B(LdaSmi), U8(1),
- B(Add), R(4),
- B(Star), R(1),
- B(Star), R(4),
- B(LdaSmi), U8(2),
- B(TestEqualStrict), R(4),
- B(JumpIfTrue), U8(4),
- B(Jump), U8(8),
- B(LdaSmi), U8(1),
- B(Star), R(2),
- B(Jump), U8(8),
- B(LdaSmi), U8(2),
- B(Star), R(2),
- B(Jump), U8(2),
- B(LdaSmi), U8(3),
- B(Star), R(2),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(2),
+ /* 52 E> */ B(Star), R(0),
+ /* 45 S> */ B(Star), R(3),
+ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(3),
+ B(JumpIfTrue), U8(10),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(3),
+ B(JumpIfTrue), U8(36),
+ B(Jump), U8(38),
+ /* 77 E> */ B(Ldar), R(2),
+ B(Star), R(4),
+ B(LdaSmi), U8(1),
+ B(Add), R(4),
+ /* 79 E> */ B(Star), R(1),
+ /* 70 S> */ B(Star), R(4),
+ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(4),
+ B(JumpIfTrue), U8(4),
+ B(Jump), U8(8),
+ /* 101 S> */ B(LdaSmi), U8(1),
+ /* 103 E> */ B(Star), R(2),
+ /* 108 S> */ B(Jump), U8(8),
+ /* 131 S> */ B(LdaSmi), U8(2),
+ /* 133 E> */ B(Star), R(2),
+ /* 138 S> */ B(Jump), U8(2),
+ /* 176 S> */ B(LdaSmi), U8(3),
+ /* 178 E> */ B(Star), R(2),
+ B(LdaUndefined),
+ /* 185 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/ThisFunction.golden b/test/cctest/interpreter/bytecode_expectations/ThisFunction.golden
index da84a49..5d7328b 100644
--- a/test/cctest/interpreter/bytecode_expectations/ThisFunction.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ThisFunction.golden
@@ -14,21 +14,15 @@
f = function f() {};
f();
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 19
+bytecode array length: 7
bytecodes: [
- B(LdaTheHole),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(closure),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(5),
- B(Mov), R(1), R(0),
- B(Ldar), R(1),
- B(LdaUndefined),
- B(Return),
+ /* 21 E> */ B(StackCheck),
+ B(Ldar), R(closure),
+ B(Star), R(0),
+ B(LdaUndefined),
+ /* 25 S> */ B(Return),
]
constant pool: [
]
@@ -41,23 +35,14 @@
f = function f() { return f; };
f();
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 23
+bytecode array length: 6
bytecodes: [
- B(LdaTheHole),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(closure),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(5),
- B(Mov), R(1), R(0),
- B(Ldar), R(1),
- B(Ldar), R(0),
- B(JumpIfNotHole), U8(3),
- B(LdaUndefined),
- B(Return),
+ /* 21 E> */ B(StackCheck),
+ B(Ldar), R(closure),
+ B(Star), R(0),
+ /* 36 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/Throw.golden b/test/cctest/interpreter/bytecode_expectations/Throw.golden
index 99e17fc..7c671ac 100644
--- a/test/cctest/interpreter/bytecode_expectations/Throw.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Throw.golden
@@ -15,9 +15,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Throw),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaSmi), U8(1),
+ /* 34 E> */ B(Throw),
]
constant pool: [
]
@@ -32,9 +32,9 @@
parameter count: 1
bytecode array length: 4
bytecodes: [
- B(StackCheck),
- B(LdaConstant), U8(0),
- B(Throw),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaConstant), U8(0),
+ /* 34 E> */ B(Throw),
]
constant pool: [
"Error",
@@ -50,14 +50,14 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(JumpIfToBooleanFalse), U8(5),
- B(LdaConstant), U8(0),
- B(Throw),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanFalse), U8(5),
+ /* 54 S> */ B(LdaConstant), U8(0),
+ /* 54 E> */ B(Throw),
+ B(LdaUndefined),
+ /* 72 S> */ B(Return),
]
constant pool: [
"Error",
diff --git a/test/cctest/interpreter/bytecode_expectations/TopLevelObjectLiterals.golden b/test/cctest/interpreter/bytecode_expectations/TopLevelObjectLiterals.golden
index 23d3609..e1d0ec3 100644
--- a/test/cctest/interpreter/bytecode_expectations/TopLevelObjectLiterals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/TopLevelObjectLiterals.golden
@@ -16,25 +16,25 @@
parameter count: 1
bytecode array length: 44
bytecodes: [
- B(LdaConstant), U8(0),
- B(Star), R(1),
- B(LdaZero),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kDeclareGlobals), R(1), U8(2),
- B(StackCheck),
- B(LdaConstant), U8(1),
- B(Star), R(1),
- B(LdaZero),
- B(Star), R(2),
- B(CreateObjectLiteral), U8(2), U8(0), U8(5),
- B(Star), R(4),
- B(CreateClosure), U8(3), U8(0),
- B(StoreICSloppy), R(4), U8(4), U8(3),
- B(Ldar), R(4),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kInitializeVarGlobal), R(1), U8(3),
- B(LdaUndefined),
- B(Return),
+ B(LdaConstant), U8(0),
+ B(Star), R(1),
+ B(LdaZero),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kDeclareGlobals), R(1), U8(2),
+ /* 0 E> */ B(StackCheck),
+ /* 8 S> */ B(LdaConstant), U8(1),
+ B(Star), R(1),
+ B(LdaZero),
+ B(Star), R(2),
+ B(CreateObjectLiteral), U8(2), U8(0), U8(1),
+ B(Star), R(4),
+ B(CreateClosure), U8(3), U8(0),
+ B(StoreICSloppy), R(4), U8(4), U8(3),
+ B(Ldar), R(4),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kInitializeVarGlobal), R(1), U8(3),
+ B(LdaUndefined),
+ /* 33 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
diff --git a/test/cctest/interpreter/bytecode_expectations/TryCatch.golden b/test/cctest/interpreter/bytecode_expectations/TryCatch.golden
index 20abd3e..b57baf8 100644
--- a/test/cctest/interpreter/bytecode_expectations/TryCatch.golden
+++ b/test/cctest/interpreter/bytecode_expectations/TryCatch.golden
@@ -15,25 +15,25 @@
parameter count: 1
bytecode array length: 40
bytecodes: [
- B(StackCheck),
- B(Mov), R(context), R(1),
- B(LdaSmi), U8(1),
- B(Return),
- B(Star), R(3),
- B(LdaConstant), U8(0),
- B(Star), R(2),
- B(Ldar), R(closure),
- B(Star), R(4),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(2), U8(3),
- B(Star), R(1),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Ldar), R(1),
- B(PushContext), R(0),
- B(LdaSmi), U8(2),
- B(PopContext), R(0),
- B(Return),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ B(Mov), R(context), R(1),
+ /* 40 S> */ B(LdaSmi), U8(1),
+ /* 75 S> */ B(Return),
+ B(Star), R(3),
+ B(LdaConstant), U8(0),
+ B(Star), R(2),
+ B(Ldar), R(closure),
+ B(Star), R(4),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(2), U8(3),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(1),
+ B(PushContext), R(0),
+ /* 63 S> */ B(LdaSmi), U8(2),
+ B(PopContext), R(0),
+ /* 75 S> */ B(Return),
+ B(LdaUndefined),
+ /* 75 S> */ B(Return),
]
constant pool: [
"e",
@@ -52,41 +52,41 @@
parameter count: 1
bytecode array length: 81
bytecodes: [
- B(StackCheck),
- B(Mov), R(context), R(2),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Jump), U8(30),
- B(Star), R(4),
- B(LdaConstant), U8(0),
- B(Star), R(3),
- B(Ldar), R(closure),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(3), U8(3),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Ldar), R(2),
- B(PushContext), R(1),
- B(PopContext), R(1),
- B(Mov), R(context), R(2),
- B(LdaSmi), U8(2),
- B(Star), R(0),
- B(Jump), U8(34),
- B(Star), R(4),
- B(LdaConstant), U8(1),
- B(Star), R(3),
- B(Ldar), R(closure),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(3), U8(3),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Ldar), R(2),
- B(PushContext), R(1),
- B(LdaSmi), U8(3),
- B(Star), R(0),
- B(PopContext), R(1),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ B(Mov), R(context), R(2),
+ /* 47 S> */ B(LdaSmi), U8(1),
+ /* 49 E> */ B(Star), R(0),
+ B(Jump), U8(30),
+ B(Star), R(4),
+ B(LdaConstant), U8(0),
+ B(Star), R(3),
+ B(Ldar), R(closure),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(3), U8(3),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(2),
+ B(PushContext), R(1),
+ B(PopContext), R(1),
+ B(Mov), R(context), R(2),
+ /* 75 S> */ B(LdaSmi), U8(2),
+ /* 77 E> */ B(Star), R(0),
+ B(Jump), U8(34),
+ B(Star), R(4),
+ B(LdaConstant), U8(1),
+ B(Star), R(3),
+ B(Ldar), R(closure),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(3), U8(3),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(2),
+ B(PushContext), R(1),
+ /* 95 S> */ B(LdaSmi), U8(3),
+ /* 97 E> */ B(Star), R(0),
+ B(PopContext), R(1),
+ B(LdaUndefined),
+ /* 103 S> */ B(Return),
]
constant pool: [
"e1",
diff --git a/test/cctest/interpreter/bytecode_expectations/TryFinally.golden b/test/cctest/interpreter/bytecode_expectations/TryFinally.golden
index e14a709..bd29e1a 100644
--- a/test/cctest/interpreter/bytecode_expectations/TryFinally.golden
+++ b/test/cctest/interpreter/bytecode_expectations/TryFinally.golden
@@ -16,31 +16,31 @@
parameter count: 1
bytecode array length: 51
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Mov), R(context), R(3),
- B(LdaSmi), U8(2),
- B(Star), R(0),
- B(LdaSmi), U8(-1),
- B(Star), R(1),
- B(Jump), U8(7),
- B(Star), R(2),
- B(LdaZero),
- B(Star), R(1),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Star), R(3),
- B(LdaSmi), U8(3),
- B(Star), R(0),
- B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(3), U8(1),
- B(LdaZero),
- B(TestEqualStrict), R(1),
- B(JumpIfTrue), U8(4),
- B(Jump), U8(5),
- B(Ldar), R(2),
- B(ReThrow),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ B(Mov), R(context), R(3),
+ /* 51 S> */ B(LdaSmi), U8(2),
+ /* 53 E> */ B(Star), R(0),
+ B(LdaSmi), U8(-1),
+ B(Star), R(1),
+ B(Jump), U8(7),
+ B(Star), R(2),
+ B(LdaZero),
+ B(Star), R(1),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(3),
+ /* 70 S> */ B(LdaSmi), U8(3),
+ /* 72 E> */ B(Star), R(0),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(3), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(1),
+ B(JumpIfTrue), U8(4),
+ B(Jump), U8(5),
+ B(Ldar), R(2),
+ B(ReThrow),
+ B(LdaUndefined),
+ /* 79 S> */ B(Return),
]
constant pool: [
]
@@ -57,46 +57,46 @@
parameter count: 1
bytecode array length: 88
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Mov), R(context), R(4),
- B(Mov), R(context), R(5),
- B(LdaSmi), U8(2),
- B(Star), R(0),
- B(Jump), U8(34),
- B(Star), R(7),
- B(LdaConstant), U8(0),
- B(Star), R(6),
- B(Ldar), R(closure),
- B(Star), R(8),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(6), U8(3),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Ldar), R(5),
- B(PushContext), R(1),
- B(LdaSmi), U8(20),
- B(Star), R(0),
- B(PopContext), R(1),
- B(LdaSmi), U8(-1),
- B(Star), R(2),
- B(Jump), U8(7),
- B(Star), R(3),
- B(LdaZero),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Star), R(4),
- B(LdaSmi), U8(3),
- B(Star), R(0),
- B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(4), U8(1),
- B(LdaZero),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(4),
- B(Jump), U8(5),
- B(Ldar), R(3),
- B(ReThrow),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(Star), R(0),
+ B(Mov), R(context), R(4),
+ B(Mov), R(context), R(5),
+ /* 51 S> */ B(LdaSmi), U8(2),
+ /* 53 E> */ B(Star), R(0),
+ B(Jump), U8(34),
+ B(Star), R(7),
+ B(LdaConstant), U8(0),
+ B(Star), R(6),
+ B(Ldar), R(closure),
+ B(Star), R(8),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(6), U8(3),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(5),
+ B(PushContext), R(1),
+ /* 71 S> */ B(LdaSmi), U8(20),
+ /* 73 E> */ B(Star), R(0),
+ B(PopContext), R(1),
+ B(LdaSmi), U8(-1),
+ B(Star), R(2),
+ B(Jump), U8(7),
+ B(Star), R(3),
+ B(LdaZero),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(4),
+ /* 90 S> */ B(LdaSmi), U8(3),
+ /* 92 E> */ B(Star), R(0),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(4), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(4),
+ B(Jump), U8(5),
+ B(Ldar), R(3),
+ B(ReThrow),
+ B(LdaUndefined),
+ /* 99 S> */ B(Return),
]
constant pool: [
"e",
@@ -116,59 +116,59 @@
parameter count: 1
bytecode array length: 121
bytecodes: [
- B(StackCheck),
- B(Mov), R(context), R(4),
- B(Mov), R(context), R(5),
- B(Mov), R(context), R(6),
- B(LdaSmi), U8(1),
- B(Star), R(0),
- B(Jump), U8(34),
- B(Star), R(8),
- B(LdaConstant), U8(0),
- B(Star), R(7),
- B(Ldar), R(closure),
- B(Star), R(9),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(7), U8(3),
- B(Star), R(6),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Ldar), R(6),
- B(PushContext), R(1),
- B(LdaSmi), U8(2),
- B(Star), R(0),
- B(PopContext), R(1),
- B(Jump), U8(34),
- B(Star), R(7),
- B(LdaConstant), U8(0),
- B(Star), R(6),
- B(Ldar), R(closure),
- B(Star), R(8),
- B(CallRuntime), U16(Runtime::kPushCatchContext), R(6), U8(3),
- B(Star), R(5),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Ldar), R(5),
- B(PushContext), R(1),
- B(LdaSmi), U8(20),
- B(Star), R(0),
- B(PopContext), R(1),
- B(LdaSmi), U8(-1),
- B(Star), R(2),
- B(Jump), U8(7),
- B(Star), R(3),
- B(LdaZero),
- B(Star), R(2),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
- B(Star), R(4),
- B(LdaSmi), U8(3),
- B(Star), R(0),
- B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(4), U8(1),
- B(LdaZero),
- B(TestEqualStrict), R(2),
- B(JumpIfTrue), U8(4),
- B(Jump), U8(5),
- B(Ldar), R(3),
- B(ReThrow),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ B(Mov), R(context), R(4),
+ B(Mov), R(context), R(5),
+ B(Mov), R(context), R(6),
+ /* 55 S> */ B(LdaSmi), U8(1),
+ /* 57 E> */ B(Star), R(0),
+ B(Jump), U8(34),
+ B(Star), R(8),
+ B(LdaConstant), U8(0),
+ B(Star), R(7),
+ B(Ldar), R(closure),
+ B(Star), R(9),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(7), U8(3),
+ B(Star), R(6),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(6),
+ B(PushContext), R(1),
+ /* 74 S> */ B(LdaSmi), U8(2),
+ /* 76 E> */ B(Star), R(0),
+ B(PopContext), R(1),
+ B(Jump), U8(34),
+ B(Star), R(7),
+ B(LdaConstant), U8(0),
+ B(Star), R(6),
+ B(Ldar), R(closure),
+ B(Star), R(8),
+ B(CallRuntime), U16(Runtime::kPushCatchContext), R(6), U8(3),
+ B(Star), R(5),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Ldar), R(5),
+ B(PushContext), R(1),
+ /* 95 S> */ B(LdaSmi), U8(20),
+ /* 97 E> */ B(Star), R(0),
+ B(PopContext), R(1),
+ B(LdaSmi), U8(-1),
+ B(Star), R(2),
+ B(Jump), U8(7),
+ B(Star), R(3),
+ B(LdaZero),
+ B(Star), R(2),
+ B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ B(Star), R(4),
+ /* 114 S> */ B(LdaSmi), U8(3),
+ /* 116 E> */ B(Star), R(0),
+ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(4), U8(1),
+ B(LdaZero),
+ B(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(4),
+ B(Jump), U8(5),
+ B(Ldar), R(3),
+ B(ReThrow),
+ B(LdaUndefined),
+ /* 123 S> */ B(Return),
]
constant pool: [
"e",
diff --git a/test/cctest/interpreter/bytecode_expectations/Typeof.golden b/test/cctest/interpreter/bytecode_expectations/Typeof.golden
index e5db7a7..b0e80dd 100644
--- a/test/cctest/interpreter/bytecode_expectations/Typeof.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Typeof.golden
@@ -20,11 +20,11 @@
parameter count: 1
bytecode array length: 7
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(13),
- B(Star), R(0),
- B(TypeOf),
- B(Return),
+ /* 10 E> */ B(StackCheck),
+ /* 24 S> */ B(LdaSmi), U8(13),
+ /* 24 E> */ B(Star), R(0),
+ /* 29 S> */ B(TypeOf),
+ /* 47 S> */ B(Return),
]
constant pool: [
]
@@ -43,10 +43,10 @@
parameter count: 1
bytecode array length: 6
bytecodes: [
- B(StackCheck),
- B(LdaGlobalInsideTypeof), U8(0), U8(1),
- B(TypeOf),
- B(Return),
+ /* 22 E> */ B(StackCheck),
+ /* 28 S> */ B(LdaGlobalInsideTypeof), U8(0), U8(1),
+ B(TypeOf),
+ /* 46 S> */ B(Return),
]
constant pool: [
"x",
diff --git a/test/cctest/interpreter/bytecode_expectations/UnaryOperators.golden b/test/cctest/interpreter/bytecode_expectations/UnaryOperators.golden
index 0a3ca76..f253be9 100644
--- a/test/cctest/interpreter/bytecode_expectations/UnaryOperators.golden
+++ b/test/cctest/interpreter/bytecode_expectations/UnaryOperators.golden
@@ -19,24 +19,24 @@
parameter count: 1
bytecode array length: 31
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(10),
- B(TestEqual), R(1),
- B(LogicalNot),
- B(JumpIfFalse), U8(15),
- B(StackCheck),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(10),
- B(Add), R(1),
- B(Star), R(0),
- B(Jump), U8(-22),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaZero),
+ /* 42 E> */ B(Star), R(0),
+ /* 54 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(10),
+ /* 54 E> */ B(TestEqual), R(1),
+ B(LogicalNot),
+ B(JumpIfFalse), U8(15),
+ /* 45 E> */ B(StackCheck),
+ /* 65 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaSmi), U8(10),
+ B(Add), R(1),
+ /* 67 E> */ B(Star), R(0),
+ B(Jump), U8(-22),
+ /* 79 S> */ B(Ldar), R(0),
+ /* 89 S> */ B(Return),
]
constant pool: [
]
@@ -55,20 +55,20 @@
parameter count: 1
bytecode array length: 22
bytecodes: [
- B(StackCheck),
- B(LdaFalse),
- B(Star), R(0),
- B(StackCheck),
- B(Ldar), R(0),
- B(LogicalNot),
- B(Star), R(0),
- B(Ldar), R(0),
- B(Star), R(1),
- B(LdaFalse),
- B(TestEqual), R(1),
- B(JumpIfTrue), U8(-13),
- B(Ldar), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaFalse),
+ /* 42 E> */ B(Star), R(0),
+ /* 49 E> */ B(StackCheck),
+ /* 56 S> */ B(Ldar), R(0),
+ B(ToBooleanLogicalNot),
+ /* 58 E> */ B(Star), R(0),
+ /* 74 S> */ B(Ldar), R(0),
+ B(Star), R(1),
+ B(LdaFalse),
+ /* 74 E> */ B(TestEqual), R(1),
+ B(JumpIfTrue), U8(-13),
+ /* 85 S> */ B(Ldar), R(0),
+ /* 95 S> */ B(Return),
]
constant pool: [
]
@@ -84,14 +84,14 @@
parameter count: 1
bytecode array length: 13
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(101),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(3),
- B(Mul), R(1),
- B(LdaUndefined),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(101),
+ /* 42 E> */ B(Star), R(0),
+ /* 47 S> */ B(Star), R(1),
+ B(LdaSmi), U8(3),
+ B(Mul), R(1),
+ B(LdaUndefined),
+ /* 67 S> */ B(Return),
]
constant pool: [
]
@@ -108,18 +108,18 @@
parameter count: 1
bytecode array length: 23
bytecodes: [
- B(StackCheck),
- B(Wide), B(LdaSmi), U16(1234),
- B(Star), R(0),
- B(Star), R(2),
- B(Ldar), R(0),
- B(Mul), R(2),
- B(Star), R(3),
- B(LdaSmi), U8(1),
- B(Sub), R(3),
- B(LdaUndefined),
- B(Star), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(Wide), B(LdaSmi), U16(1234),
+ /* 42 E> */ B(Star), R(0),
+ /* 56 S> */ B(Star), R(2),
+ /* 66 E> */ B(Ldar), R(0),
+ B(Mul), R(2),
+ B(Star), R(3),
+ B(LdaSmi), U8(1),
+ B(Sub), R(3),
+ B(LdaUndefined),
+ /* 56 E> */ B(Star), R(1),
+ /* 84 S> */ B(Return),
]
constant pool: [
]
@@ -135,13 +135,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(13),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(-1),
- B(BitwiseXor), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(13),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(Star), R(1),
+ B(LdaSmi), U8(-1),
+ B(BitwiseXor), R(1),
+ /* 57 S> */ B(Return),
]
constant pool: [
]
@@ -157,13 +157,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(13),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(1),
- B(Mul), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(13),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(Star), R(1),
+ B(LdaSmi), U8(1),
+ B(Mul), R(1),
+ /* 57 S> */ B(Return),
]
constant pool: [
]
@@ -179,13 +179,13 @@
parameter count: 1
bytecode array length: 12
bytecodes: [
- B(StackCheck),
- B(LdaSmi), U8(13),
- B(Star), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(-1),
- B(Mul), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 42 S> */ B(LdaSmi), U8(13),
+ /* 42 E> */ B(Star), R(0),
+ /* 46 S> */ B(Star), R(1),
+ B(LdaSmi), U8(-1),
+ B(Mul), R(1),
+ /* 57 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/WideRegisters.golden b/test/cctest/interpreter/bytecode_expectations/WideRegisters.golden
index 9300775..2c23cce 100644
--- a/test/cctest/interpreter/bytecode_expectations/WideRegisters.golden
+++ b/test/cctest/interpreter/bytecode_expectations/WideRegisters.golden
@@ -171,12 +171,12 @@
"
frame size: 157
parameter count: 1
-bytecode array length: 6
+bytecode array length: 8
bytecodes: [
- B(StackCheck),
- B(Ldar), R(127),
- B(Star), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 1494 S> */ B(Wide), B(Ldar), R16(127),
+ /* 1497 E> */ B(Star), R(0),
+ /* 1516 S> */ B(Return),
]
constant pool: [
]
@@ -347,12 +347,12 @@
"
frame size: 157
parameter count: 1
-bytecode array length: 6
+bytecode array length: 10
bytecodes: [
- B(StackCheck),
- B(Ldar), R(126),
- B(Star), R(127),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 1494 S> */ B(Wide), B(Ldar), R16(126),
+ /* 1499 E> */ B(Wide), B(Star), R16(127),
+ /* 1520 S> */ B(Return),
]
constant pool: [
]
@@ -523,18 +523,18 @@
"
frame size: 158
parameter count: 1
-bytecode array length: 23
+bytecode array length: 25
bytecodes: [
- B(StackCheck),
- B(Ldar), R(2),
- B(Wide), B(Star), R16(157),
- B(LdaSmi), U8(3),
- B(Wide), B(TestGreaterThan), R16(157),
- B(JumpIfFalse), U8(7),
- B(Wide), B(Ldar), R16(129),
- B(Return),
- B(Ldar), R(128),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 1494 S> */ B(Ldar), R(2),
+ B(Wide), B(Star), R16(157),
+ B(LdaSmi), U8(3),
+ /* 1501 E> */ B(Wide), B(TestGreaterThan), R16(157),
+ B(JumpIfFalse), U8(7),
+ /* 1508 S> */ B(Wide), B(Ldar), R16(129),
+ /* 1536 S> */ B(Return),
+ /* 1523 S> */ B(Wide), B(Ldar), R16(128),
+ /* 1536 S> */ B(Return),
]
constant pool: [
]
@@ -709,25 +709,25 @@
parameter count: 1
bytecode array length: 48
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(Wide), B(Ldar), R16(129),
- B(Wide), B(Star), R16(157),
- B(LdaSmi), U8(3),
- B(Wide), B(TestEqual), R16(157),
- B(JumpIfFalse), U8(8),
- B(Ldar), R(0),
- B(Wide), B(Star), R16(129),
- B(Ldar), R(2),
- B(Wide), B(Star), R16(157),
- B(LdaSmi), U8(3),
- B(Wide), B(TestGreaterThan), R16(157),
- B(JumpIfFalse), U8(5),
- B(Ldar), R(0),
- B(Return),
- B(Wide), B(Ldar), R16(129),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 1503 S> */ B(LdaZero),
+ /* 1503 E> */ B(Star), R(0),
+ /* 1506 S> */ B(Wide), B(Ldar), R16(129),
+ B(Wide), B(Star), R16(157),
+ B(LdaSmi), U8(3),
+ /* 1515 E> */ B(Wide), B(TestEqual), R16(157),
+ B(JumpIfFalse), U8(8),
+ /* 1534 S> */ B(Ldar), R(0),
+ /* 1534 E> */ B(Wide), B(Star), R16(129),
+ /* 1540 S> */ B(Ldar), R(2),
+ B(Wide), B(Star), R16(157),
+ B(LdaSmi), U8(3),
+ /* 1547 E> */ B(Wide), B(TestGreaterThan), R16(157),
+ B(JumpIfFalse), U8(5),
+ /* 1554 S> */ B(Ldar), R(0),
+ /* 1580 S> */ B(Return),
+ /* 1567 S> */ B(Wide), B(Ldar), R16(129),
+ /* 1580 S> */ B(Return),
]
constant pool: [
]
@@ -899,34 +899,34 @@
"
frame size: 158
parameter count: 1
-bytecode array length: 54
+bytecode array length: 66
bytecodes: [
- B(StackCheck),
- B(LdaZero),
- B(Star), R(0),
- B(LdaZero),
- B(Star), R(1),
- B(LdaZero),
- B(Star), R(128),
- B(Ldar), R(128),
- B(Wide), B(Star), R16(157),
- B(LdaSmi), U8(64),
- B(Wide), B(TestLessThan), R16(157),
- B(JumpIfFalse), U8(29),
- B(StackCheck),
- B(Ldar), R(1),
- B(Wide), B(Star), R16(157),
- B(Ldar), R(128),
- B(Wide), B(Add), R16(157),
- B(Star), R(1),
- B(Ldar), R(128),
- B(ToNumber),
- B(Wide), B(Star), R16(157),
- B(Inc),
- B(Star), R(128),
- B(Jump), U8(-39),
- B(Ldar), R(128),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 1503 S> */ B(LdaZero),
+ /* 1503 E> */ B(Star), R(0),
+ /* 1515 S> */ B(LdaZero),
+ /* 1515 E> */ B(Star), R(1),
+ /* 1523 S> */ B(LdaZero),
+ /* 1528 E> */ B(Wide), B(Star), R16(128),
+ /* 1538 S> */ B(Wide), B(Ldar), R16(128),
+ B(Wide), B(Star), R16(157),
+ B(LdaSmi), U8(64),
+ /* 1538 E> */ B(Wide), B(TestLessThan), R16(157),
+ B(JumpIfFalse), U8(35),
+ /* 1518 E> */ B(StackCheck),
+ /* 1555 S> */ B(Ldar), R(1),
+ B(Wide), B(Star), R16(157),
+ /* 1561 E> */ B(Wide), B(Ldar), R16(128),
+ B(Wide), B(Add), R16(157),
+ /* 1558 E> */ B(Star), R(1),
+ /* 1548 S> */ B(Wide), B(Ldar), R16(128),
+ B(ToNumber),
+ B(Wide), B(Star), R16(157),
+ B(Inc),
+ /* 1548 E> */ B(Wide), B(Star), R16(128),
+ B(Jump), U8(-47),
+ /* 1567 S> */ B(Wide), B(Ldar), R16(128),
+ /* 1580 S> */ B(Return),
]
constant pool: [
]
@@ -1098,37 +1098,37 @@
"
frame size: 163
parameter count: 1
-bytecode array length: 80
+bytecode array length: 84
bytecodes: [
- B(StackCheck),
- B(Wide), B(LdaSmi), U16(1234),
- B(Star), R(0),
- B(LdaZero),
- B(Star), R(1),
- B(Ldar), R(0),
- B(JumpIfUndefined), U8(65),
- B(JumpIfNull), U8(63),
- B(ToObject),
- B(Wide), B(Star), R16(157),
- B(Wide), B(ForInPrepare), R16(158),
- B(LdaZero),
- B(Wide), B(Star), R16(161),
- B(Wide), B(ForInDone), R16(161), R16(160),
- B(JumpIfTrue), U8(41),
- B(Wide), B(ForInNext), R16(157), R16(161), R16(158), U16(1),
- B(JumpIfUndefined), U8(19),
- B(Star), R(128),
- B(StackCheck),
- B(Ldar), R(1),
- B(Wide), B(Star), R16(162),
- B(Ldar), R(128),
- B(Wide), B(Add), R16(162),
- B(Star), R(1),
- B(Wide), B(ForInStep), R16(161),
- B(Wide), B(Star), R16(161),
- B(Jump), U8(-45),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 1503 S> */ B(Wide), B(LdaSmi), U16(1234),
+ /* 1503 E> */ B(Star), R(0),
+ /* 1518 S> */ B(LdaZero),
+ /* 1518 E> */ B(Star), R(1),
+ /* 1534 S> */ B(Ldar), R(0),
+ B(JumpIfUndefined), U8(69),
+ B(JumpIfNull), U8(67),
+ B(ToObject),
+ B(Wide), B(Star), R16(157),
+ B(Wide), B(ForInPrepare), R16(158),
+ B(LdaZero),
+ B(Wide), B(Star), R16(161),
+ /* 1526 S> */ B(Wide), B(ForInDone), R16(161), R16(160),
+ B(JumpIfTrue), U8(45),
+ B(Wide), B(ForInNext), R16(157), R16(161), R16(158), U16(1),
+ B(JumpIfUndefined), U8(23),
+ B(Wide), B(Star), R16(128),
+ /* 1521 E> */ B(StackCheck),
+ /* 1541 S> */ B(Ldar), R(1),
+ B(Wide), B(Star), R16(162),
+ /* 1547 E> */ B(Wide), B(Ldar), R16(128),
+ B(Wide), B(Add), R16(162),
+ /* 1544 E> */ B(Star), R(1),
+ B(Wide), B(ForInStep), R16(161),
+ B(Wide), B(Star), R16(161),
+ B(Jump), U8(-49),
+ /* 1553 S> */ B(Ldar), R(1),
+ /* 1564 S> */ B(Return),
]
constant pool: [
]
@@ -1303,22 +1303,22 @@
parameter count: 1
bytecode array length: 55
bytecodes: [
- B(StackCheck),
- B(Ldar), R(64),
- B(Wide), B(Star), R16(157),
- B(Ldar), R(63),
- B(Wide), B(Star), R16(158),
- B(Wide), B(CallRuntime), U16(Runtime::kAdd), R16(157), U16(2),
- B(Star), R(0),
- B(Ldar), R(27),
- B(Wide), B(Star), R16(157),
- B(Wide), B(Ldar), R16(143),
- B(Wide), B(Star), R16(158),
- B(Wide), B(CallRuntime), U16(Runtime::kAdd), R16(157), U16(2),
- B(Star), R(1),
- B(CallRuntime), U16(Runtime::kTheHole), R(0), U8(0),
- B(Ldar), R(1),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 1494 S> */ B(Ldar), R(64),
+ B(Wide), B(Star), R16(157),
+ /* 1509 E> */ B(Ldar), R(63),
+ B(Wide), B(Star), R16(158),
+ B(Wide), B(CallRuntime), U16(Runtime::kAdd), R16(157), U16(2),
+ /* 1497 E> */ B(Star), R(0),
+ /* 1515 S> */ B(Ldar), R(27),
+ B(Wide), B(Star), R16(157),
+ /* 1530 E> */ B(Wide), B(Ldar), R16(143),
+ B(Wide), B(Star), R16(158),
+ B(Wide), B(CallRuntime), U16(Runtime::kAdd), R16(157), U16(2),
+ /* 1518 E> */ B(Star), R(1),
+ /* 1537 S> */ B(CallRuntime), U16(Runtime::kTheHole), R(0), U8(0),
+ /* 1549 S> */ B(Ldar), R(1),
+ /* 1560 S> */ B(Return),
]
constant pool: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/WithStatement.golden b/test/cctest/interpreter/bytecode_expectations/WithStatement.golden
index 350a0a5..e1b7eda 100644
--- a/test/cctest/interpreter/bytecode_expectations/WithStatement.golden
+++ b/test/cctest/interpreter/bytecode_expectations/WithStatement.golden
@@ -15,18 +15,18 @@
parameter count: 1
bytecode array length: 26
bytecodes: [
- B(StackCheck),
- B(CreateObjectLiteral), U8(0), U8(0), U8(5),
- B(Star), R(1),
- B(ToObject),
- B(Star), R(2),
- B(Ldar), R(closure),
- B(Star), R(3),
- B(CallRuntime), U16(Runtime::kPushWithContext), R(2), U8(2),
- B(PushContext), R(0),
- B(LdaLookupSlot), U8(1),
- B(PopContext), R(0),
- B(Return),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
+ B(Star), R(1),
+ B(ToObject),
+ B(Star), R(2),
+ B(Ldar), R(closure),
+ B(Star), R(3),
+ B(CallRuntime), U16(Runtime::kPushWithContext), R(2), U8(2),
+ B(PushContext), R(0),
+ /* 50 S> */ B(LdaLookupSlot), U8(1),
+ B(PopContext), R(0),
+ /* 62 S> */ B(Return),
]
constant pool: [
InstanceType::FIXED_ARRAY_TYPE,
diff --git a/test/cctest/interpreter/generate-bytecode-expectations.cc b/test/cctest/interpreter/generate-bytecode-expectations.cc
index 92ba9ba..f3dfd06 100644
--- a/test/cctest/interpreter/generate-bytecode-expectations.cc
+++ b/test/cctest/interpreter/generate-bytecode-expectations.cc
@@ -44,6 +44,7 @@
execute_(true),
top_level_(false),
do_expressions_(false),
+ ignition_generators_(false),
verbose_(false),
const_pool_type_(
BytecodeExpectationsPrinter::ConstantPoolType::kMixed) {}
@@ -64,6 +65,7 @@
bool execute() const { return execute_; }
bool top_level() const { return top_level_; }
bool do_expressions() const { return do_expressions_; }
+ bool ignition_generators() const { return ignition_generators_; }
bool verbose() const { return verbose_; }
bool suppress_runtime_errors() const { return rebaseline_ && !verbose_; }
BytecodeExpectationsPrinter::ConstantPoolType const_pool_type() const {
@@ -83,6 +85,7 @@
bool execute_;
bool top_level_;
bool do_expressions_;
+ bool ignition_generators_;
bool verbose_;
BytecodeExpectationsPrinter::ConstantPoolType const_pool_type_;
std::vector<std::string> input_filenames_;
@@ -212,6 +215,8 @@
options.top_level_ = true;
} else if (strcmp(argv[i], "--do-expressions") == 0) {
options.do_expressions_ = true;
+ } else if (strcmp(argv[i], "--ignition-generators") == 0) {
+ options.ignition_generators_ = true;
} else if (strcmp(argv[i], "--verbose") == 0) {
options.verbose_ = true;
} else if (strncmp(argv[i], "--output=", 9) == 0) {
@@ -316,6 +321,8 @@
top_level_ = ParseBoolean(line.c_str() + 11);
} else if (line.compare(0, 16, "do expressions: ") == 0) {
do_expressions_ = ParseBoolean(line.c_str() + 16);
+ } else if (line.compare(0, 21, "ignition generators: ") == 0) {
+ ignition_generators_ = ParseBoolean(line.c_str() + 21);
} else if (line == "---") {
break;
} else if (line.empty()) {
@@ -340,6 +347,7 @@
if (top_level_) stream << "\ntop level: yes";
if (do_expressions_) stream << "\ndo expressions: yes";
+ if (ignition_generators_) stream << "\nignition generators: yes";
stream << "\n\n";
}
@@ -445,6 +453,7 @@
}
if (options.do_expressions()) i::FLAG_harmony_do_expressions = true;
+ if (options.ignition_generators()) i::FLAG_ignition_generators = true;
stream << "#\n# Autogenerated by generate-bytecode-expectations.\n#\n\n";
options.PrintHeader(stream);
@@ -497,6 +506,7 @@
"Specify the name of the test function.\n"
" --top-level Process top level code, not the top-level function.\n"
" --do-expressions Enable harmony_do_expressions flag.\n"
+ " --ignition-generators Enable ignition_generators flag.\n"
" --output=file.name\n"
" Specify the output file. If not specified, output goes to "
"stdout.\n"
diff --git a/test/cctest/interpreter/test-bytecode-generator.cc b/test/cctest/interpreter/test-bytecode-generator.cc
index 2519f25..3d0fe6f 100644
--- a/test/cctest/interpreter/test-bytecode-generator.cc
+++ b/test/cctest/interpreter/test-bytecode-generator.cc
@@ -113,6 +113,44 @@
return actual_stream.str();
}
+bool CompareTexts(const std::string& generated, const std::string& expected) {
+ std::istringstream generated_stream(generated);
+ std::istringstream expected_stream(expected);
+ std::string generated_line;
+ std::string expected_line;
+ // Line number does not include golden file header.
+ int line_number = 0;
+
+ do {
+ std::getline(generated_stream, generated_line);
+ std::getline(expected_stream, expected_line);
+
+ if (!generated_stream.good() && !expected_stream.good()) {
+ return true;
+ }
+
+ if (!generated_stream.good()) {
+ std::cerr << "Expected has extra lines after line " << line_number
+ << "\n";
+ std::cerr << " Expected: '" << expected_line << "'\n";
+ return false;
+ } else if (!expected_stream.good()) {
+ std::cerr << "Generated has extra lines after line " << line_number
+ << "\n";
+ std::cerr << " Generated: '" << generated_line << "'\n";
+ return false;
+ }
+
+ if (generated_line != expected_line) {
+ std::cerr << "Inputs differ at line " << line_number << "\n";
+ std::cerr << " Generated: '" << generated_line << "'\n";
+ std::cerr << " Expected: '" << expected_line << "'\n";
+ return false;
+ }
+ line_number++;
+ } while (true);
+}
+
using ConstantPoolType = BytecodeExpectationsPrinter::ConstantPoolType;
TEST(PrimitiveReturnStatements) {
@@ -122,27 +160,27 @@
const char* snippets[] = {
"",
- "return;",
+ "return;\n",
- "return null;",
+ "return null;\n",
- "return true;",
+ "return true;\n",
- "return false;",
+ "return false;\n",
- "return 0;",
+ "return 0;\n",
- "return +1;",
+ "return +1;\n",
- "return -1;",
+ "return -1;\n",
- "return +127;",
+ "return +127;\n",
- "return -128;",
+ "return -128;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("PrimitiveReturnStatements.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("PrimitiveReturnStatements.golden")));
}
TEST(PrimitiveExpressions) {
@@ -150,35 +188,35 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kNumber);
const char* snippets[] = {
- "var x = 0; return x;",
+ "var x = 0; return x;\n",
- "var x = 0; return x + 3;",
+ "var x = 0; return x + 3;\n",
- "var x = 0; return x - 3;",
+ "var x = 0; return x - 3;\n",
- "var x = 4; return x * 3;",
+ "var x = 4; return x * 3;\n",
- "var x = 4; return x / 3;",
+ "var x = 4; return x / 3;\n",
- "var x = 4; return x % 3;",
+ "var x = 4; return x % 3;\n",
- "var x = 1; return x | 2;",
+ "var x = 1; return x | 2;\n",
- "var x = 1; return x ^ 2;",
+ "var x = 1; return x ^ 2;\n",
- "var x = 1; return x & 2;",
+ "var x = 1; return x & 2;\n",
- "var x = 10; return x << 3;",
+ "var x = 10; return x << 3;\n",
- "var x = 10; return x >> 3;",
+ "var x = 10; return x >> 3;\n",
- "var x = 10; return x >>> 3;",
+ "var x = 10; return x >>> 3;\n",
- "var x = 0; return (x, 3);",
+ "var x = 0; return (x, 3);\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("PrimitiveExpressions.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("PrimitiveExpressions.golden")));
}
TEST(LogicalExpressions) {
@@ -186,43 +224,43 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kNumber);
const char* snippets[] = {
- "var x = 0; return x || 3;",
+ "var x = 0; return x || 3;\n",
- "var x = 0; return (x == 1) || 3;",
+ "var x = 0; return (x == 1) || 3;\n",
- "var x = 0; return x && 3;",
+ "var x = 0; return x && 3;\n",
- "var x = 0; return (x == 0) && 3;",
+ "var x = 0; return (x == 0) && 3;\n",
- "var x = 0; return x || (1, 2, 3);",
+ "var x = 0; return x || (1, 2, 3);\n",
- "var a = 2, b = 3, c = 4; return a || (a, b, a, b, c = 5, 3);",
+ "var a = 2, b = 3, c = 4; return a || (a, b, a, b, c = 5, 3);\n",
"var x = 1; var a = 2, b = 3; return x || (" //
REPEAT_32("\n a = 1, b = 2, ") //
- "3);",
+ "3);\n",
"var x = 0; var a = 2, b = 3; return x && (" //
REPEAT_32("\n a = 1, b = 2, ") //
- "3);",
+ "3);\n",
"var x = 1; var a = 2, b = 3; return (x > 3) || (" //
REPEAT_32("\n a = 1, b = 2, ") //
- "3);",
+ "3);\n",
"var x = 0; var a = 2, b = 3; return (x < 5) && (" //
REPEAT_32("\n a = 1, b = 2, ") //
- "3);",
+ "3);\n",
- "return 0 && 3;",
+ "return 0 && 3;\n",
- "return 1 || 3;",
+ "return 1 || 3;\n",
- "var x = 1; return x && 3 || 0, 1;",
+ "var x = 1; return x && 3 || 0, 1;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("LogicalExpressions.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("LogicalExpressions.golden")));
}
TEST(Parameters) {
@@ -248,8 +286,8 @@
"function f(arg1, arg2, arg3, arg4) { arg2 = 1; }",
};
- CHECK_EQ(BuildActual(printer, snippets, "", "\nf();"),
- LoadGolden("Parameters.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
+ LoadGolden("Parameters.golden")));
}
TEST(IntegerConstants) {
@@ -257,15 +295,15 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kNumber);
const char* snippets[] = {
- "return 12345678;",
+ "return 12345678;\n",
- "var a = 1234; return 5678;",
+ "var a = 1234; return 5678;\n",
- "var a = 1234; return 1234;",
+ "var a = 1234; return 1234;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("IntegerConstants.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("IntegerConstants.golden")));
}
TEST(HeapNumberConstants) {
@@ -273,19 +311,19 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kNumber);
const char* snippets[] = {
- "return 1.2;",
+ "return 1.2;\n",
- "var a = 1.2; return 2.6;",
+ "var a = 1.2; return 2.6;\n",
- "var a = 3.14; return 3.14;",
+ "var a = 3.14; return 3.14;\n",
"var a;" //
REPEAT_256("\na = 1.414;") //
- " a = 3.14;",
+ " a = 3.14;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("HeapNumberConstants.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("HeapNumberConstants.golden")));
}
TEST(StringConstants) {
@@ -293,15 +331,15 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kString);
const char* snippets[] = {
- "return \"This is a string\";",
+ "return \"This is a string\";\n",
- "var a = \"First string\"; return \"Second string\";",
+ "var a = \"First string\"; return \"Second string\";\n",
- "var a = \"Same string\"; return \"Same string\";",
+ "var a = \"Same string\"; return \"Same string\";\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("StringConstants.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("StringConstants.golden")));
}
TEST(PropertyLoads) {
@@ -313,16 +351,16 @@
const char* snippets[] = {
"function f(a) { return a.name; }\n"
- "f({name : \"test\"});",
+ "f({name : \"test\"});\n",
"function f(a) { return a[\"key\"]; }\n"
- "f({key : \"test\"});",
+ "f({key : \"test\"});\n",
"function f(a) { return a[100]; }\n"
- "f({100 : \"test\"});",
+ "f({100 : \"test\"});\n",
"function f(a, b) { return a[b]; }\n"
- "f({arg : \"test\"}, \"arg\");",
+ "f({arg : \"test\"}, \"arg\");\n",
"function f(a) { var b = a.name; return a[-124]; }\n"
"f({\"-124\" : \"test\", name : 123 })",
@@ -344,7 +382,8 @@
"f({name : \"test\"}, \"name\")\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("PropertyLoads.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("PropertyLoads.golden")));
}
TEST(PropertyStores) {
@@ -407,7 +446,8 @@
"f({name : \"test\"})\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("PropertyStores.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("PropertyStores.golden")));
}
#define FUNC_ARG "new (function Obj() { this.func = function() { return; }})()"
@@ -436,7 +476,8 @@
"f(" FUNC_ARG ")",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("PropertyCall.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("PropertyCall.golden")));
}
TEST(LoadGlobal) {
@@ -465,10 +506,11 @@
REPEAT_127(" b.name;\n")
" return a;\n"
"}\n"
- "f({name: 1});",
+ "f({name: 1});\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("LoadGlobal.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("LoadGlobal.golden")));
}
TEST(StoreGlobal) {
@@ -481,18 +523,18 @@
const char* snippets[] = {
"var a = 1;\n"
"function f() { a = 2; }\n"
- "f();",
+ "f();\n",
"var a = \"test\"; function f(b) { a = b; }\n"
- "f(\"global\");",
+ "f(\"global\");\n",
"'use strict'; var a = 1;\n"
"function f() { a = 2; }\n"
- "f();",
+ "f();\n",
"a = 1;\n"
"function f() { a = 2; }\n"
- "f();",
+ "f();\n",
"a = 1;\n"
"function f(b) {\n"
@@ -500,7 +542,7 @@
REPEAT_127(" b.name;\n")
" a = 2;\n"
"}\n"
- "f({name: 1});",
+ "f({name: 1});\n",
"a = 1;\n"
"function f(b) {\n"
@@ -509,10 +551,11 @@
REPEAT_127(" b.name;\n")
" a = 2;\n"
"}\n"
- "f({name: 1});",
+ "f({name: 1});\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("StoreGlobal.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("StoreGlobal.golden")));
}
TEST(CallGlobal) {
@@ -525,14 +568,15 @@
const char* snippets[] = {
"function t() { }\n"
"function f() { return t(); }\n"
- "f();",
+ "f();\n",
"function t(a, b, c) { }\n"
"function f() { return t(1, 2, 3); }\n"
- "f();",
+ "f();\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("CallGlobal.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("CallGlobal.golden")));
}
TEST(CallRuntime) {
@@ -544,30 +588,26 @@
const char* snippets[] = {
"function f() { %TheHole() }\n"
- "f();",
+ "f();\n",
"function f(a) { return %IsArray(a) }\n"
- "f(undefined);",
+ "f(undefined);\n",
"function f() { return %Add(1, 2) }\n"
- "f();",
+ "f();\n",
"function f() { return %spread_iterable([1]) }\n"
- "f();",
+ "f();\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("CallRuntime.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("CallRuntime.golden")));
}
TEST(IfConditions) {
- if (FLAG_harmony_instanceof) {
- // TODO(mvstanton): when ES6 instanceof ships, regenerate the bytecode
- // expectations and remove this flag check.
- return;
- }
InitializedIgnitionHandleScope scope;
BytecodeExpectationsPrinter printer(CcTest::isolate(),
- ConstantPoolType::kNumber);
+ ConstantPoolType::kMixed);
printer.set_wrap(false);
printer.set_test_function_name("f");
@@ -579,7 +619,7 @@
" return -1;\n"
" }\n"
"};\n"
- "f();",
+ "f();\n",
"function f() {\n"
" if ('lucky') {\n"
@@ -588,7 +628,7 @@
" return -1;\n"
" }\n"
"};\n"
- "f();",
+ "f();\n",
"function f() {\n"
" if (false) {\n"
@@ -597,14 +637,14 @@
" return -1;\n"
" }\n"
"};\n"
- "f();",
+ "f();\n",
"function f() {\n"
" if (false) {\n"
" return 1;\n"
" }\n"
"};\n"
- "f();",
+ "f();\n",
"function f() {\n"
" var a = 1;\n"
@@ -614,7 +654,7 @@
" return 2;\n"
" }\n"
"};\n"
- "f();",
+ "f();\n",
"function f(a) {\n"
" if (a <= 0) {\n"
@@ -623,14 +663,14 @@
" return -200;\n"
" }\n"
"};\n"
- "f(99);",
+ "f(99);\n",
"function f(a, b) { if (a in b) { return 200; } }"
- "f('prop', { prop: 'yes'});",
+ "f('prop', { prop: 'yes'});\n",
"function f(z) { var a = 0; var b = 0; if (a === 0.01) {\n"
REPEAT_64(" b = a; a = b;\n")
- " return 200; } else { return -200; } } f(0.001);",
+ " return 200; } else { return -200; } } f(0.001);\n",
"function f() {\n"
" var a = 0; var b = 0;\n"
@@ -638,7 +678,7 @@
REPEAT_64(" b = a; a = b;\n")
" return 200; } else { return -200; }\n"
"};\n"
- "f();",
+ "f();\n",
"function f(a, b) {\n"
" if (a == b) { return 1; }\n"
@@ -651,7 +691,7 @@
" if (a instanceof b) { return 1; }\n"
" return 0;\n"
"}\n"
- "f(1, 1);",
+ "f(1, 1);\n",
"function f() {\n"
" var a = 0;\n"
@@ -661,10 +701,11 @@
" return -20;\n"
" }\n"
"};\n"
- "f();",
+ "f();\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("IfConditions.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("IfConditions.golden")));
}
TEST(DeclareGlobals) {
@@ -677,18 +718,19 @@
printer.set_top_level(true);
const char* snippets[] = {
- "var a = 1;",
+ "var a = 1;\n",
- "function f() {}",
+ "function f() {}\n",
"var a = 1;\n"
- "a=2;",
+ "a=2;\n",
"function f() {}\n"
- "f();",
+ "f();\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("DeclareGlobals.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("DeclareGlobals.golden")));
}
TEST(BreakableBlocks) {
@@ -703,7 +745,7 @@
" break label;\n"
" x = x + 1;\n"
"}\n"
- "return x;",
+ "return x;\n",
"var sum = 0;\n"
"outer: {\n"
@@ -714,7 +756,7 @@
" }\n"
" }\n"
"}\n"
- "return sum;",
+ "return sum;\n",
"outer: {\n"
" let y = 10;\n"
@@ -731,11 +773,11 @@
" y = 3;\n"
" }\n"
"}\n"
- "x = 4;",
+ "x = 4;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("BreakableBlocks.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("BreakableBlocks.golden")));
}
TEST(BasicLoops) {
@@ -745,13 +787,13 @@
const char* snippets[] = {
"var x = 0;\n"
"while (false) { x = 99; break; continue; }\n"
- "return x;",
+ "return x;\n",
"var x = 0;\n"
"while (false) {\n"
" x = x + 1;\n"
"};\n"
- "return x;",
+ "return x;\n",
"var x = 0;\n"
"var y = 1;\n"
@@ -761,7 +803,7 @@
" if (x == 3) continue;\n"
" if (x == 4) break;\n"
"}\n"
- "return y;",
+ "return y;\n",
"var i = 0;\n"
"while (true) {\n"
@@ -772,7 +814,7 @@
" if (i == 5) break;\n"
" i = i + 1;\n"
"}\n"
- "return i;",
+ "return i;\n",
"var i = 0;\n"
"while (true) {\n"
@@ -783,7 +825,7 @@
" i = i + 1;\n"
" break;\n"
"}\n"
- "return i;",
+ "return i;\n",
"var x = 10;\n"
"var y = 1;\n"
@@ -791,7 +833,7 @@
" y = y * 12;\n"
" x = x - 1;\n"
"}\n"
- "return y;",
+ "return y;\n",
"var x = 0; var y = 1;\n"
"do {\n"
@@ -800,7 +842,7 @@
" if (x == 6) continue;\n"
" x = x + 1;\n"
"} while (x < 10);\n"
- "return y;",
+ "return y;\n",
"var x = 10;\n"
"var y = 1;\n"
@@ -808,7 +850,7 @@
" y = y * 12;\n"
" x = x - 1;\n"
"} while (x);\n"
- "return y;",
+ "return y;\n",
"var x = 0; var y = 1;\n"
"do {\n"
@@ -817,7 +859,7 @@
" x = x + 1;\n"
" if (x == 6) continue;\n"
"} while (false);\n"
- "return y;",
+ "return y;\n",
"var x = 0; var y = 1;\n"
"do {\n"
@@ -826,56 +868,56 @@
" x = x + 1;\n"
" if (x == 6) continue;\n"
"} while (true);\n"
- "return y;",
+ "return y;\n",
"var x = 0;\n"
"for (;;) {\n"
" if (x == 1) break;\n"
" if (x == 2) continue;\n"
" x = x + 1;\n"
- "}",
+ "}\n",
"for (var x = 0;;) {\n"
" if (x == 1) break;\n"
" if (x == 2) continue;\n"
" x = x + 1;\n"
- "}",
+ "}\n",
"var x = 0;\n"
"for (;; x = x + 1) {\n"
" if (x == 1) break;\n"
" if (x == 2) continue;\n"
- "}",
+ "}\n",
"for (var x = 0;; x = x + 1) {\n"
" if (x == 1) break;\n"
" if (x == 2) continue;\n"
- "}",
+ "}\n",
"var u = 0;\n"
"for (var i = 0; i < 100; i = i + 1) {\n"
" u = u + 1;\n"
" continue;\n"
- "}",
+ "}\n",
"var y = 1;\n"
"for (var x = 10; x; --x) {\n"
" y = y * 12;\n"
"}\n"
- "return y;",
+ "return y;\n",
"var x = 0;\n"
"for (var i = 0; false; i++) {\n"
" x = x + 1;\n"
"};\n"
- "return x;",
+ "return x;\n",
"var x = 0;\n"
"for (var i = 0; true; ++i) {\n"
" x = x + 1;\n"
" if (x == 20) break;\n"
"};\n"
- "return x;",
+ "return x;\n",
"var a = 0;\n"
"while (a) {\n"
@@ -885,10 +927,11 @@
" if (z) continue;\n"
" z++;\n"
" }\n"
- "}",
+ "}\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("BasicLoops.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("BasicLoops.golden")));
}
TEST(JumpsRequiringConstantWideOperands) {
@@ -904,11 +947,11 @@
" if (i == 1) continue;\n"
" if (i == 2) break;\n"
"}\n"
- "return 3;",
+ "return 3;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("JumpsRequiringConstantWideOperands.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("JumpsRequiringConstantWideOperands.golden")));
}
TEST(UnaryOperators) {
@@ -920,32 +963,33 @@
"while (x != 10) {\n"
" x = x + 10;\n"
"}\n"
- "return x;",
+ "return x;\n",
"var x = false;\n"
"do {\n"
" x = !x;\n"
"} while(x == false);\n"
- "return x;",
+ "return x;\n",
"var x = 101;\n"
- "return void(x * 3);",
+ "return void(x * 3);\n",
"var x = 1234;\n"
"var y = void (x * x - 1);\n"
- "return y;",
+ "return y;\n",
"var x = 13;\n"
- "return ~x;",
+ "return ~x;\n",
"var x = 13;\n"
- "return +x;",
+ "return +x;\n",
"var x = 13;\n"
- "return -x;",
+ "return -x;\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("UnaryOperators.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("UnaryOperators.golden")));
}
TEST(Typeof) {
@@ -967,8 +1011,8 @@
"};",
};
- CHECK_EQ(BuildActual(printer, snippets, "", "\nf();"),
- LoadGolden("Typeof.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
+ LoadGolden("Typeof.golden")));
}
TEST(Delete) {
@@ -977,23 +1021,24 @@
ConstantPoolType::kMixed);
const char* snippets[] = {
- "var a = {x:13, y:14}; return delete a.x;",
+ "var a = {x:13, y:14}; return delete a.x;\n",
- "'use strict'; var a = {x:13, y:14}; return delete a.x;",
+ "'use strict'; var a = {x:13, y:14}; return delete a.x;\n",
- "var a = {1:13, 2:14}; return delete a[2];",
+ "var a = {1:13, 2:14}; return delete a[2];\n",
- "var a = 10; return delete a;",
+ "var a = 10; return delete a;\n",
"'use strict';\n"
"var a = {1:10};\n"
"(function f1() {return a;});\n"
- "return delete a[1];",
+ "return delete a[1];\n",
- "return delete 'test';",
+ "return delete 'test';\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("Delete.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("Delete.golden")));
}
TEST(GlobalDelete) {
@@ -1008,29 +1053,30 @@
"function f() {\n"
" return delete a.x;\n"
"};\n"
- "f();",
+ "f();\n",
"a = {1:13, 2:14};\n"
"function f() {\n"
" 'use strict';\n"
" return delete a[1];\n"
"};\n"
- "f();",
+ "f();\n",
"var a = {x:13, y:14};\n"
"function f() {\n"
" return delete a;\n"
"};\n"
- "f();",
+ "f();\n",
"b = 30;\n"
"function f() {\n"
" return delete b;\n"
"};\n"
- "f();",
+ "f();\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("GlobalDelete.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("GlobalDelete.golden")));
}
TEST(FunctionLiterals) {
@@ -1039,15 +1085,15 @@
ConstantPoolType::kMixed);
const char* snippets[] = {
- "return function(){ }",
+ "return function(){ }\n",
- "return (function(){ })()",
+ "return (function(){ })()\n",
- "return (function(x){ return x; })(1)",
+ "return (function(x){ return x; })(1)\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("FunctionLiterals.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("FunctionLiterals.golden")));
}
TEST(RegExpLiterals) {
@@ -1056,14 +1102,15 @@
ConstantPoolType::kString);
const char* snippets[] = {
- "return /ab+d/;",
+ "return /ab+d/;\n",
- "return /(\\w+)\\s(\\w+)/i;",
+ "return /(\\w+)\\s(\\w+)/i;\n",
- "return /ab+d/.exec('abdd');",
+ "return /ab+d/.exec('abdd');\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("RegExpLiterals.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("RegExpLiterals.golden")));
}
TEST(RegExpLiteralsWide) {
@@ -1074,11 +1121,11 @@
const char* snippets[] = {
"var a;" //
REPEAT_256("\na = 1.23;") //
- "\nreturn /ab+d/;",
+ "\nreturn /ab+d/;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("RegExpLiteralsWide.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("RegExpLiteralsWide.golden")));
}
TEST(ArrayLiterals) {
@@ -1087,16 +1134,17 @@
ConstantPoolType::kMixed);
const char* snippets[] = {
- "return [ 1, 2 ];",
+ "return [ 1, 2 ];\n",
- "var a = 1; return [ a, a + 1 ];",
+ "var a = 1; return [ a, a + 1 ];\n",
- "return [ [ 1, 2 ], [ 3 ] ];",
+ "return [ [ 1, 2 ], [ 3 ] ];\n",
- "var a = 1; return [ [ a, 2 ], [ a + 2 ] ];",
+ "var a = 1; return [ [ a, 2 ], [ a + 2 ] ];\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("ArrayLiterals.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("ArrayLiterals.golden")));
}
TEST(ArrayLiteralsWide) {
@@ -1107,11 +1155,11 @@
const char* snippets[] = {
"var a;" //
REPEAT_256("\na = 1.23;") //
- "\nreturn [ 1 , 2 ];",
+ "\nreturn [ 1 , 2 ];\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("ArrayLiteralsWide.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("ArrayLiteralsWide.golden")));
}
TEST(ObjectLiterals) {
@@ -1120,38 +1168,39 @@
ConstantPoolType::kMixed);
const char* snippets[] = {
- "return { };",
+ "return { };\n",
- "return { name: 'string', val: 9.2 };",
+ "return { name: 'string', val: 9.2 };\n",
- "var a = 1; return { name: 'string', val: a };",
+ "var a = 1; return { name: 'string', val: a };\n",
- "var a = 1; return { val: a, val: a + 1 };",
+ "var a = 1; return { val: a, val: a + 1 };\n",
- "return { func: function() { } };",
+ "return { func: function() { } };\n",
- "return { func(a) { return a; } };",
+ "return { func(a) { return a; } };\n",
- "return { get a() { return 2; } };",
+ "return { get a() { return 2; } };\n",
- "return { get a() { return this.x; }, set a(val) { this.x = val } };",
+ "return { get a() { return this.x; }, set a(val) { this.x = val } };\n",
- "return { set b(val) { this.y = val } };",
+ "return { set b(val) { this.y = val } };\n",
- "var a = 1; return { 1: a };",
+ "var a = 1; return { 1: a };\n",
- "return { __proto__: null };",
+ "return { __proto__: null };\n",
- "var a = 'test'; return { [a]: 1 };",
+ "var a = 'test'; return { [a]: 1 };\n",
- "var a = 'test'; return { val: a, [a]: 1 };",
+ "var a = 'test'; return { val: a, [a]: 1 };\n",
- "var a = 'test'; return { [a]: 1, __proto__: {} };",
+ "var a = 'test'; return { [a]: 1, __proto__: {} };\n",
- "var n = 'name'; return { [n]: 'val', get a() { }, set a(b) {} };",
+ "var n = 'name'; return { [n]: 'val', get a() { }, set a(b) {} };\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("ObjectLiterals.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("ObjectLiterals.golden")));
}
TEST(ObjectLiteralsWide) {
@@ -1161,11 +1210,11 @@
const char* snippets[] = {
"var a;" //
REPEAT_256("\na = 1.23;") //
- "\nreturn { name: 'string', val: 9.2 };",
+ "\nreturn { name: 'string', val: 9.2 };\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("ObjectLiteralsWide.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("ObjectLiteralsWide.golden")));
}
TEST(TopLevelObjectLiterals) {
@@ -1178,11 +1227,11 @@
printer.set_top_level(true);
const char* snippets[] = {
- "var a = { func: function() { } };",
+ "var a = { func: function() { } };\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("TopLevelObjectLiterals.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("TopLevelObjectLiterals.golden")));
}
TEST(TryCatch) {
@@ -1191,14 +1240,15 @@
ConstantPoolType::kString);
const char* snippets[] = {
- "try { return 1; } catch(e) { return 2; }",
+ "try { return 1; } catch(e) { return 2; }\n",
"var a;\n"
"try { a = 1 } catch(e1) {};\n"
- "try { a = 2 } catch(e2) { a = 3 }",
+ "try { a = 2 } catch(e2) { a = 3 }\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("TryCatch.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("TryCatch.golden")));
}
TEST(TryFinally) {
@@ -1207,17 +1257,18 @@
ConstantPoolType::kString);
const char* snippets[] = {
"var a = 1;\n"
- "try { a = 2; } finally { a = 3; }",
+ "try { a = 2; } finally { a = 3; }\n",
"var a = 1;\n"
- "try { a = 2; } catch(e) { a = 20 } finally { a = 3; }",
+ "try { a = 2; } catch(e) { a = 20 } finally { a = 3; }\n",
"var a; try {\n"
" try { a = 1 } catch(e) { a = 2 }\n"
- "} catch(e) { a = 20 } finally { a = 3; }",
+ "} catch(e) { a = 20 } finally { a = 3; }\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("TryFinally.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("TryFinally.golden")));
}
TEST(Throw) {
@@ -1225,14 +1276,15 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kString);
const char* snippets[] = {
- "throw 1;",
+ "throw 1;\n",
- "throw 'Error';",
+ "throw 'Error';\n",
- "var a = 1; if (a) { throw 'Error'; };",
+ "var a = 1; if (a) { throw 'Error'; };\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("Throw.golden"));
+ CHECK(
+ CompareTexts(BuildActual(printer, snippets), LoadGolden("Throw.golden")));
}
TEST(CallNew) {
@@ -1245,11 +1297,11 @@
const char* snippets[] = {
"function bar() { this.value = 0; }\n"
"function f() { return new bar(); }\n"
- "f();",
+ "f();\n",
"function bar(x) { this.value = 18; this.x = x;}\n"
"function f() { return new bar(3); }\n"
- "f();",
+ "f();\n",
"function bar(w, x, y, z) {\n"
" this.value = 18;\n"
@@ -1258,10 +1310,11 @@
" this.z = z;\n"
"}\n"
"function f() { return new bar(3, 4, 5); }\n"
- "f();",
+ "f();\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("CallNew.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("CallNew.golden")));
}
TEST(ContextVariables) {
@@ -1274,27 +1327,27 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kMixed);
const char* snippets[] = {
- "var a; return function() { a = 1; };",
+ "var a; return function() { a = 1; };\n",
- "var a = 1; return function() { a = 2; };",
+ "var a = 1; return function() { a = 2; };\n",
- "var a = 1; var b = 2; return function() { a = 2; b = 3 };",
+ "var a = 1; var b = 2; return function() { a = 2; b = 3 };\n",
- "var a; (function() { a = 2; })(); return a;",
+ "var a; (function() { a = 2; })(); return a;\n",
"'use strict';\n"
"let a = 1;\n"
- "{ let b = 2; return function() { a + b; }; }",
+ "{ let b = 2; return function() { a + b; }; }\n",
"'use strict';\n"
REPEAT_249_UNIQUE_VARS()
"eval();\n"
"var b = 100;\n"
- "return b",
+ "return b\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("ContextVariables.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("ContextVariables.golden")));
}
TEST(ContextParameters) {
@@ -1314,8 +1367,8 @@
"function f() { var self = this; return function() { self = 2; }; }",
};
- CHECK_EQ(BuildActual(printer, snippets, "", "\nf();"),
- LoadGolden("ContextParameters.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
+ LoadGolden("ContextParameters.golden")));
}
TEST(OuterContextVariables) {
@@ -1345,8 +1398,8 @@
"var f = new Outer().getInnerFunc();",
};
- CHECK_EQ(BuildActual(printer, snippets, "", "\nf();"),
- LoadGolden("OuterContextVariables.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
+ LoadGolden("OuterContextVariables.golden")));
}
TEST(CountOperators) {
@@ -1354,30 +1407,31 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kMixed);
const char* snippets[] = {
- "var a = 1; return ++a;",
+ "var a = 1; return ++a;\n",
- "var a = 1; return a++;",
+ "var a = 1; return a++;\n",
- "var a = 1; return --a;",
+ "var a = 1; return --a;\n",
- "var a = 1; return a--;",
+ "var a = 1; return a--;\n",
- "var a = { val: 1 }; return a.val++;",
+ "var a = { val: 1 }; return a.val++;\n",
- "var a = { val: 1 }; return --a.val;",
+ "var a = { val: 1 }; return --a.val;\n",
- "var name = 'var'; var a = { val: 1 }; return a[name]--;",
+ "var name = 'var'; var a = { val: 1 }; return a[name]--;\n",
- "var name = 'var'; var a = { val: 1 }; return ++a[name];",
+ "var name = 'var'; var a = { val: 1 }; return ++a[name];\n",
- "var a = 1; var b = function() { return a }; return ++a;",
+ "var a = 1; var b = function() { return a }; return ++a;\n",
- "var a = 1; var b = function() { return a }; return a--;",
+ "var a = 1; var b = function() { return a }; return a--;\n",
- "var idx = 1; var a = [1, 2]; return a[idx++] = 2;",
+ "var idx = 1; var a = [1, 2]; return a[idx++] = 2;\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("CountOperators.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("CountOperators.golden")));
}
TEST(GlobalCountOperators) {
@@ -1390,23 +1444,23 @@
const char* snippets[] = {
"var global = 1;\n"
"function f() { return ++global; }\n"
- "f();",
+ "f();\n",
"var global = 1;\n"
"function f() { return global--; }\n"
- "f();",
+ "f();\n",
"unallocated = 1;\n"
"function f() { 'use strict'; return --unallocated; }\n"
- "f();",
+ "f();\n",
"unallocated = 1;\n"
"function f() { return unallocated++; }\n"
- "f();",
+ "f();\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("GlobalCountOperators.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("GlobalCountOperators.golden")));
}
TEST(CompoundExpressions) {
@@ -1414,19 +1468,19 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kMixed);
const char* snippets[] = {
- "var a = 1; a += 2;",
+ "var a = 1; a += 2;\n",
- "var a = 1; a /= 2;",
+ "var a = 1; a /= 2;\n",
- "var a = { val: 2 }; a.name *= 2;",
+ "var a = { val: 2 }; a.name *= 2;\n",
- "var a = { 1: 2 }; a[1] ^= 2;",
+ "var a = { 1: 2 }; a[1] ^= 2;\n",
- "var a = 1; (function f() { return a; }); a |= 24;",
+ "var a = 1; (function f() { return a; }); a |= 24;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("CompoundExpressions.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("CompoundExpressions.golden")));
}
TEST(GlobalCompoundExpressions) {
@@ -1439,15 +1493,15 @@
const char* snippets[] = {
"var global = 1;\n"
"function f() { return global &= 1; }\n"
- "f();",
+ "f();\n",
"unallocated = 1;\n"
"function f() { return unallocated += 1; }\n"
- "f();",
+ "f();\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("GlobalCompoundExpressions.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("GlobalCompoundExpressions.golden")));
}
TEST(CreateArguments) {
@@ -1471,8 +1525,8 @@
"function f(a, b, c) { 'use strict'; return arguments; }",
};
- CHECK_EQ(BuildActual(printer, snippets, "", "\nf();"),
- LoadGolden("CreateArguments.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
+ LoadGolden("CreateArguments.golden")));
}
TEST(CreateRestParameter) {
@@ -1492,8 +1546,8 @@
"function f(a, ...restArgs) { return restArgs[0] + arguments[0]; }",
};
- CHECK_EQ(BuildActual(printer, snippets, "", "\nf();"),
- LoadGolden("CreateRestParameter.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
+ LoadGolden("CreateRestParameter.golden")));
}
TEST(ForIn) {
@@ -1501,29 +1555,30 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kMixed);
const char* snippets[] = {
- "for (var p in null) {}",
+ "for (var p in null) {}\n",
- "for (var p in undefined) {}",
+ "for (var p in undefined) {}\n",
- "for (var p in undefined) {}",
+ "for (var p in undefined) {}\n",
"var x = 'potatoes';\n"
- "for (var p in x) { return p; }",
+ "for (var p in x) { return p; }\n",
"var x = 0;\n"
- "for (var p in [1,2,3]) { x += p; }",
+ "for (var p in [1,2,3]) { x += p; }\n",
"var x = { 'a': 1, 'b': 2 };\n"
"for (x['a'] in [10, 20, 30]) {\n"
" if (x['a'] == 10) continue;\n"
" if (x['a'] == 20) break;\n"
- "}",
+ "}\n",
"var x = [ 10, 11, 12 ] ;\n"
- "for (x[0] in [1,2,3]) { return x[3]; }",
+ "for (x[0] in [1,2,3]) { return x[3]; }\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("ForIn.golden"));
+ CHECK(
+ CompareTexts(BuildActual(printer, snippets), LoadGolden("ForIn.golden")));
}
TEST(ForOf) {
@@ -1531,21 +1586,22 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kMixed);
const char* snippets[] = {
- "for (var p of [0, 1, 2]) {}",
+ "for (var p of [0, 1, 2]) {}\n",
"var x = 'potatoes';\n"
- "for (var p of x) { return p; }",
+ "for (var p of x) { return p; }\n",
"for (var x of [10, 20, 30]) {\n"
" if (x == 10) continue;\n"
" if (x == 20) break;\n"
- "}",
+ "}\n",
"var x = { 'a': 1, 'b': 2 };\n"
- "for (x['a'] of [1,2,3]) { return x['a']; }",
+ "for (x['a'] of [1,2,3]) { return x['a']; }\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("ForOf.golden"));
+ CHECK(
+ CompareTexts(BuildActual(printer, snippets), LoadGolden("ForOf.golden")));
}
TEST(Conditional) {
@@ -1553,12 +1609,13 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kNumber);
const char* snippets[] = {
- "return 1 ? 2 : 3;",
+ "return 1 ? 2 : 3;\n",
- "return 1 ? 2 ? 3 : 4 : 5;",
+ "return 1 ? 2 ? 3 : 4 : 5;\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("Conditional.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("Conditional.golden")));
}
TEST(Switch) {
@@ -1570,39 +1627,39 @@
"switch(a) {\n"
" case 1: return 2;\n"
" case 2: return 3;\n"
- "}",
+ "}\n",
"var a = 1;\n"
"switch(a) {\n"
" case 1: a = 2; break;\n"
" case 2: a = 3; break;\n"
- "}",
+ "}\n",
"var a = 1;\n"
"switch(a) {\n"
" case 1: a = 2; // fall-through\n"
" case 2: a = 3; break;\n"
- "}",
+ "}\n",
"var a = 1;\n"
"switch(a) {\n"
" case 2: break;\n"
" case 3: break;\n"
" default: a = 1; break;\n"
- "}",
+ "}\n",
"var a = 1;\n"
"switch(typeof(a)) {\n"
" case 2: a = 1; break;\n"
" case 3: a = 2; break;\n"
" default: a = 3; break;\n"
- "}",
+ "}\n",
"var a = 1;\n"
"switch(a) {\n"
" case typeof(a): a = 1; break;\n"
" default: a = 2; break;\n"
- "}",
+ "}\n",
"var a = 1;\n"
"switch(a) {\n"
@@ -1612,7 +1669,7 @@
" case 2:\n"
" a = 3;\n"
" break;\n"
- "}",
+ "}\n",
"var a = 1;\n"
"switch(a) {\n"
@@ -1622,10 +1679,11 @@
" default : a = 2; break;\n"
" } // fall-through\n"
" case 2: a = 3;\n"
- "}",
+ "}\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("Switch.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("Switch.golden")));
}
TEST(BasicBlockToBoolean) {
@@ -1633,15 +1691,15 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kNumber);
const char* snippets[] = {
- "var a = 1; if (a || a < 0) { return 1; }",
+ "var a = 1; if (a || a < 0) { return 1; }\n",
- "var a = 1; if (a && a < 0) { return 1; }",
+ "var a = 1; if (a && a < 0) { return 1; }\n",
- "var a = 1; a = (a || a < 0) ? 2 : 3;",
+ "var a = 1; a = (a || a < 0) ? 2 : 3;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("BasicBlockToBoolean.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("BasicBlockToBoolean.golden")));
}
TEST(DeadCodeRemoval) {
@@ -1649,17 +1707,17 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kNumber);
const char* snippets[] = {
- "return; var a = 1; a();",
+ "return; var a = 1; a();\n",
- "if (false) { return; }; var a = 1;",
+ "if (false) { return; }; var a = 1;\n",
- "if (true) { return 1; } else { return 2; };",
+ "if (true) { return 1; } else { return 2; };\n",
- "var a = 1; if (a) { return 1; }; return 2;",
+ "var a = 1; if (a) { return 1; }; return 2;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("DeadCodeRemoval.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("DeadCodeRemoval.golden")));
}
TEST(ThisFunction) {
@@ -1677,8 +1735,8 @@
"f = function f() { return f; };",
};
- CHECK_EQ(BuildActual(printer, snippets, "", "\nf();"),
- LoadGolden("ThisFunction.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
+ LoadGolden("ThisFunction.golden")));
}
TEST(NewTarget) {
@@ -1687,12 +1745,13 @@
ConstantPoolType::kMixed);
const char* snippets[] = {
- "return new.target;",
+ "return new.target;\n",
- "new.target;",
+ "new.target;\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("NewTarget.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("NewTarget.golden")));
}
TEST(RemoveRedundantLdar) {
@@ -1705,22 +1764,22 @@
" ld_a = ld_a + ld_a;\n" // in a different basicblock.
" if (ld_a > 10) break;\n"
"}\n"
- "return ld_a;",
+ "return ld_a;\n",
"var ld_a = 1;\n"
"do {\n"
" ld_a = ld_a + ld_a;\n"
" if (ld_a > 10) continue;\n"
"} while(false);\n"
- "return ld_a;",
+ "return ld_a;\n",
"var ld_a = 1;\n"
" ld_a = ld_a + ld_a;\n"
- " return ld_a;",
+ " return ld_a;\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("RemoveRedundantLdar.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("RemoveRedundantLdar.golden")));
}
TEST(AssignmentsInBinaryExpression) {
@@ -1729,28 +1788,28 @@
ConstantPoolType::kString);
const char* snippets[] = {
"var x = 0, y = 1;\n"
- "return (x = 2, y = 3, x = 4, y = 5);",
+ "return (x = 2, y = 3, x = 4, y = 5);\n",
"var x = 55;\n"
"var y = (x = 100);\n"
- "return y;",
+ "return y;\n",
"var x = 55;\n"
"x = x + (x = 100) + (x = 101);\n"
- "return x;",
+ "return x;\n",
"var x = 55;\n"
"x = (x = 56) - x + (x = 57);\n"
"x++;\n"
- "return x;",
+ "return x;\n",
"var x = 55;\n"
"var y = x + (x = 1) + (x = 2) + (x = 3);\n"
- "return y;",
+ "return y;\n",
"var x = 55;\n"
"var x = x + (x = 1) + (x = 2) + (x = 3);\n"
- "return x;",
+ "return x;\n",
"var x = 10, y = 20;\n"
"return x + (x = 1) + (x + 1) * (y = 2) + (y = 3) + (x = 4) + (y = 5) + "
@@ -1760,8 +1819,8 @@
"return 1 + x + (x++) + (++x);\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("AssignmentsInBinaryExpression.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("AssignmentsInBinaryExpression.golden")));
}
TEST(Eval) {
@@ -1769,10 +1828,11 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kString);
const char* snippets[] = {
- "return eval('1;');",
+ "return eval('1;');\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("Eval.golden"));
+ CHECK(
+ CompareTexts(BuildActual(printer, snippets), LoadGolden("Eval.golden")));
}
TEST(LookupSlot) {
@@ -1781,14 +1841,15 @@
ConstantPoolType::kString);
const char* snippets[] = {
- "eval('var x = 10;'); return x;",
+ "eval('var x = 10;'); return x;\n",
- "eval('var x = 10;'); return typeof x;",
+ "eval('var x = 10;'); return typeof x;\n",
- "x = 20; return eval('');",
+ "x = 20; return eval('');\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("LookupSlot.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("LookupSlot.golden")));
}
TEST(CallLookupSlot) {
@@ -1796,10 +1857,11 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kMixed);
const char* snippets[] = {
- "g = function(){}; eval(''); return g();",
+ "g = function(){}; eval(''); return g();\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("CallLookupSlot.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("CallLookupSlot.golden")));
}
// TODO(mythria): tests for variable/function declaration in lookup slots.
@@ -1831,7 +1893,7 @@
"}\n"
"f1();");
- CHECK_EQ(actual, LoadGolden("LookupSlotInEval.golden"));
+ CHECK(CompareTexts(actual, LoadGolden("LookupSlotInEval.golden")));
}
TEST(LookupSlotWideInEval) {
@@ -1867,7 +1929,7 @@
"}\n"
"f1();");
- CHECK_EQ(actual, LoadGolden("LookupSlotWideInEval.golden"));
+ CHECK(CompareTexts(actual, LoadGolden("LookupSlotWideInEval.golden")));
}
TEST(DeleteLookupSlotInEval) {
@@ -1897,7 +1959,7 @@
"}\n"
"f1();");
- CHECK_EQ(actual, LoadGolden("DeleteLookupSlotInEval.golden"));
+ CHECK(CompareTexts(actual, LoadGolden("DeleteLookupSlotInEval.golden")));
}
TEST(WideRegisters) {
@@ -1913,41 +1975,41 @@
ConstantPoolType::kNumber);
const char* snippets[] = {
"x0 = x127;\n"
- "return x0;",
+ "return x0;\n",
"x127 = x126;\n"
- "return x127;",
+ "return x127;\n",
"if (x2 > 3) { return x129; }\n"
- "return x128;",
+ "return x128;\n",
"var x0 = 0;\n"
"if (x129 == 3) { var x129 = x0; }\n"
"if (x2 > 3) { return x0; }\n"
- "return x129;",
+ "return x129;\n",
"var x0 = 0;\n"
"var x1 = 0;\n"
"for (x128 = 0; x128 < 64; x128++) {"
" x1 += x128;"
"}"
- "return x128;",
+ "return x128;\n",
"var x0 = 1234;\n"
"var x1 = 0;\n"
"for (x128 in x0) {"
" x1 += x128;"
"}"
- "return x1;",
+ "return x1;\n",
"x0 = %Add(x64, x63);\n"
"x1 = %Add(x27, x143);\n"
"%TheHole();\n"
- "return x1;",
+ "return x1;\n",
};
- CHECK_EQ(BuildActual(printer, snippets, prologue.c_str()),
- LoadGolden("WideRegisters.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets, prologue.c_str()),
+ LoadGolden("WideRegisters.golden")));
}
TEST(ConstVariable) {
@@ -1955,16 +2017,17 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kString);
const char* snippets[] = {
- "const x = 10;",
+ "const x = 10;\n",
- "const x = 10; return x;",
+ "const x = 10; return x;\n",
- "const x = ( x = 20);",
+ "const x = ( x = 20);\n",
- "const x = 10; x = 20;",
+ "const x = 10; x = 20;\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("ConstVariable.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("ConstVariable.golden")));
}
TEST(LetVariable) {
@@ -1972,16 +2035,17 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kString);
const char* snippets[] = {
- "let x = 10;",
+ "let x = 10;\n",
- "let x = 10; return x;",
+ "let x = 10; return x;\n",
- "let x = (x = 20);",
+ "let x = (x = 20);\n",
- "let x = 10; x = 20;",
+ "let x = 10; x = 20;\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("LetVariable.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("LetVariable.golden")));
}
TEST(ConstVariableContextSlot) {
@@ -1991,17 +2055,17 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kMixed);
const char* snippets[] = {
- "const x = 10; function f1() {return x;}",
+ "const x = 10; function f1() {return x;}\n",
- "const x = 10; function f1() {return x;} return x;",
+ "const x = 10; function f1() {return x;} return x;\n",
- "const x = (x = 20); function f1() {return x;}",
+ "const x = (x = 20); function f1() {return x;}\n",
- "const x = 10; x = 20; function f1() {return x;}",
+ "const x = 10; x = 20; function f1() {return x;}\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("ConstVariableContextSlot.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("ConstVariableContextSlot.golden")));
}
TEST(LetVariableContextSlot) {
@@ -2009,17 +2073,17 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kMixed);
const char* snippets[] = {
- "let x = 10; function f1() {return x;}",
+ "let x = 10; function f1() {return x;}\n",
- "let x = 10; function f1() {return x;} return x;",
+ "let x = 10; function f1() {return x;} return x;\n",
- "let x = (x = 20); function f1() {return x;}",
+ "let x = (x = 20); function f1() {return x;}\n",
- "let x = 10; x = 20; function f1() {return x;}",
+ "let x = 10; x = 20; function f1() {return x;}\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("LetVariableContextSlot.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("LetVariableContextSlot.golden")));
}
TEST(DoExpression) {
@@ -2030,14 +2094,15 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kString);
const char* snippets[] = {
- "var a = do { }; return a;",
+ "var a = do { }; return a;\n",
- "var a = do { var x = 100; }; return a;",
+ "var a = do { var x = 100; }; return a;\n",
- "while(true) { var a = 10; a = do { ++a; break; }; a = 20; }",
+ "while(true) { var a = 10; a = do { ++a; break; }; a = 20; }\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("DoExpression.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("DoExpression.golden")));
FLAG_harmony_do_expressions = old_flag;
}
@@ -2047,10 +2112,11 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kMixed);
const char* snippets[] = {
- "with ({x:42}) { return x; }",
+ "with ({x:42}) { return x; }\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("WithStatement.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("WithStatement.golden")));
}
TEST(DoDebugger) {
@@ -2058,10 +2124,11 @@
BytecodeExpectationsPrinter printer(CcTest::isolate(),
ConstantPoolType::kString);
const char* snippets[] = {
- "debugger;",
+ "debugger;\n",
};
- CHECK_EQ(BuildActual(printer, snippets), LoadGolden("DoDebugger.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("DoDebugger.golden")));
}
TEST(ClassDeclarations) {
@@ -2072,27 +2139,27 @@
"class Person {\n"
" constructor(name) { this.name = name; }\n"
" speak() { console.log(this.name + ' is speaking.'); }\n"
- "}",
+ "}\n",
"class person {\n"
" constructor(name) { this.name = name; }\n"
" speak() { console.log(this.name + ' is speaking.'); }\n"
- "}",
+ "}\n",
"var n0 = 'a';\n"
"var n1 = 'b';\n"
"class N {\n"
" [n0]() { return n0; }\n"
" static [n1]() { return n1; }\n"
- "}",
+ "}\n",
"var count = 0;\n"
"class C { constructor() { count++; }}\n"
"return new C();\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("ClassDeclarations.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("ClassDeclarations.golden")));
}
TEST(ClassAndSuperClass) {
@@ -2150,8 +2217,32 @@
"})();\n",
};
- CHECK_EQ(BuildActual(printer, snippets),
- LoadGolden("ClassAndSuperClass.golden"));
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("ClassAndSuperClass.golden")));
+}
+
+TEST(Generators) {
+ bool old_flag = FLAG_ignition_generators;
+ FLAG_ignition_generators = true;
+
+ InitializedIgnitionHandleScope scope;
+ BytecodeExpectationsPrinter printer(CcTest::isolate(),
+ ConstantPoolType::kMixed);
+ printer.set_wrap(false);
+ printer.set_test_function_name("f");
+
+ const char* snippets[] = {
+ "function* f() { }\n",
+
+ "function* f() { yield 42 }\n",
+
+ "function* f() { for (let x of [42]) yield x }\n",
+ };
+
+ CHECK(CompareTexts(BuildActual(printer, snippets),
+ LoadGolden("Generators.golden")));
+
+ FLAG_ignition_generators = old_flag;
}
} // namespace interpreter
diff --git a/test/cctest/interpreter/test-interpreter.cc b/test/cctest/interpreter/test-interpreter.cc
index c8dc776..acc93c5 100644
--- a/test/cctest/interpreter/test-interpreter.cc
+++ b/test/cctest/interpreter/test-interpreter.cc
@@ -1383,11 +1383,6 @@
TEST(InterpreterInstanceOf) {
HandleAndZoneScope handles;
- // TODO(4447): The new ES6 'instanceof' operator is fully desugared in the
- // parser and the Token::INSTANCEOF is not needed anymore. This test only
- // makes sense with --no-harmony-instanceof and can be removed once we
- // deprecate the ability to switch to old skool ES5 'instanceof' for good.
- FLAG_harmony_instanceof = false;
i::Factory* factory = handles.main_isolate()->factory();
Handle<i::String> name = factory->NewStringFromAsciiChecked("cons");
Handle<i::JSFunction> func = factory->NewFunction(name);
@@ -2259,6 +2254,8 @@
std::make_pair("function f(a, b, c, d) {"
" 'use strict'; c = b; return arguments[2]; }",
2),
+ // Check arguments for duplicate parameters in sloppy mode.
+ std::make_pair("function f(a, a, b) { return arguments[1]; }", 1),
// check rest parameters
std::make_pair("function f(...restArray) { return restArray[0]; }", 0),
std::make_pair("function f(a, ...restArray) { return restArray[0]; }", 1),
@@ -4139,6 +4136,37 @@
}
}
+TEST(InterpreterGenerators) {
+ bool old_flag = FLAG_ignition_generators;
+ FLAG_ignition_generators = true;
+
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> tests[] = {
+ {"function* f() { }; return f().next().value",
+ factory->undefined_value()},
+ {"function* f() { yield 42 }; return f().next().value",
+ factory->NewNumberFromInt(42)},
+ {"function* f() { for (let x of [42]) yield x}; return f().next().value",
+ factory->NewNumberFromInt(42)},
+ };
+
+ for (size_t i = 0; i < arraysize(tests); i++) {
+ std::string source(
+ InterpreterTester::SourceForBody(tests[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*tests[i].second));
+ }
+
+ FLAG_ignition_generators = old_flag;
+}
+
+
} // namespace interpreter
} // namespace internal
} // namespace v8
diff --git a/test/cctest/test-accessors.cc b/test/cctest/test-accessors.cc
index 67803ee..9667afb 100644
--- a/test/cctest/test-accessors.cc
+++ b/test/cctest/test-accessors.cc
@@ -775,19 +775,18 @@
}
}
-static void check_receiver(Local<String> name,
- const v8::PropertyCallbackInfo<v8::Value>& info) {
+static void CheckReceiver(Local<String> name,
+ const v8::PropertyCallbackInfo<v8::Value>& info) {
CHECK(info.This()->IsObject());
}
TEST(Regress609134) {
- v8::internal::FLAG_allow_natives_syntax = true;
LocalContext env;
v8::Isolate* isolate = env->GetIsolate();
v8::HandleScope scope(isolate);
auto fun_templ = v8::FunctionTemplate::New(isolate);
fun_templ->InstanceTemplate()->SetNativeDataProperty(v8_str("foo"),
- check_receiver);
+ CheckReceiver);
CHECK(env->Global()
->Set(env.local(), v8_str("Fun"),
@@ -797,5 +796,6 @@
CompileRun(
"var f = new Fun();"
"Number.prototype.__proto__ = f;"
- "[42][0].foo");
+ "var a = 42;"
+ "for (var i = 0; i<3; i++) { a.foo; }");
}
diff --git a/test/cctest/test-api.cc b/test/cctest/test-api.cc
index 220b0cd..da72ecd 100644
--- a/test/cctest/test-api.cc
+++ b/test/cctest/test-api.cc
@@ -2142,6 +2142,95 @@
Constructor_GetFunction_New);
}
+THREADED_TEST(TestObjectTemplateClassInheritance) {
+ LocalContext env;
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope scope(isolate);
+
+ Local<v8::FunctionTemplate> fun_A = v8::FunctionTemplate::New(isolate);
+ fun_A->SetClassName(v8_str("A"));
+
+ Local<ObjectTemplate> templ_A = fun_A->InstanceTemplate();
+ templ_A->SetNativeDataProperty(v8_str("nirk"), GetNirk);
+ templ_A->SetNativeDataProperty(v8_str("rino"), GetRino);
+
+ Local<v8::FunctionTemplate> fun_B = v8::FunctionTemplate::New(isolate);
+ v8::Local<v8::String> class_name = v8_str("B");
+ fun_B->SetClassName(class_name);
+ fun_B->Inherit(fun_A);
+
+ v8::Local<v8::String> subclass_name = v8_str("C");
+ v8::Local<v8::Object> b_proto;
+ v8::Local<v8::Object> c_proto;
+ // Perform several iterations to make sure the cache doesn't break
+ // subclassing.
+ for (int i = 0; i < 3; i++) {
+ Local<v8::Function> function_B =
+ fun_B->GetFunction(env.local()).ToLocalChecked();
+ if (i == 0) {
+ CHECK(env->Global()->Set(env.local(), class_name, function_B).FromJust());
+ CompileRun("class C extends B {}");
+ b_proto =
+ CompileRun("B.prototype")->ToObject(env.local()).ToLocalChecked();
+ c_proto =
+ CompileRun("C.prototype")->ToObject(env.local()).ToLocalChecked();
+ CHECK(b_proto->Equals(env.local(), c_proto->GetPrototype()).FromJust());
+ }
+ Local<v8::Object> instance =
+ CompileRun("new C()")->ToObject(env.local()).ToLocalChecked();
+ CHECK(c_proto->Equals(env.local(), instance->GetPrototype()).FromJust());
+
+ CHECK(subclass_name->StrictEquals(instance->GetConstructorName()));
+ CHECK(env->Global()->Set(env.local(), v8_str("o"), instance).FromJust());
+
+ CHECK_EQ(900, CompileRun("o.nirk")->IntegerValue(env.local()).FromJust());
+ CHECK_EQ(560, CompileRun("o.rino")->IntegerValue(env.local()).FromJust());
+ }
+}
+
+static void NamedPropertyGetterWhichReturns42(
+ Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
+ info.GetReturnValue().Set(v8_num(42));
+}
+
+THREADED_TEST(TestObjectTemplateReflectConstruct) {
+ LocalContext env;
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope scope(isolate);
+
+ Local<v8::FunctionTemplate> fun_B = v8::FunctionTemplate::New(isolate);
+ fun_B->InstanceTemplate()->SetHandler(
+ v8::NamedPropertyHandlerConfiguration(NamedPropertyGetterWhichReturns42));
+ v8::Local<v8::String> class_name = v8_str("B");
+ fun_B->SetClassName(class_name);
+
+ v8::Local<v8::String> subclass_name = v8_str("C");
+ v8::Local<v8::Object> b_proto;
+ v8::Local<v8::Object> c_proto;
+ // Perform several iterations to make sure the cache doesn't break
+ // subclassing.
+ for (int i = 0; i < 3; i++) {
+ Local<v8::Function> function_B =
+ fun_B->GetFunction(env.local()).ToLocalChecked();
+ if (i == 0) {
+ CHECK(env->Global()->Set(env.local(), class_name, function_B).FromJust());
+ CompileRun("function C() {}");
+ c_proto =
+ CompileRun("C.prototype")->ToObject(env.local()).ToLocalChecked();
+ }
+ Local<v8::Object> instance = CompileRun("Reflect.construct(B, [], C)")
+ ->ToObject(env.local())
+ .ToLocalChecked();
+ CHECK(c_proto->Equals(env.local(), instance->GetPrototype()).FromJust());
+
+ CHECK(subclass_name->StrictEquals(instance->GetConstructorName()));
+ CHECK(env->Global()->Set(env.local(), v8_str("o"), instance).FromJust());
+
+ CHECK_EQ(42, CompileRun("o.nirk")->IntegerValue(env.local()).FromJust());
+ CHECK_EQ(42, CompileRun("o.rino")->IntegerValue(env.local()).FromJust());
+ }
+}
+
static void GetFlabby(const v8::FunctionCallbackInfo<v8::Value>& args) {
ApiTestFuzzer::Fuzz();
args.GetReturnValue().Set(v8_num(17.2));
@@ -4687,126 +4776,6 @@
}
-// TODO(mstarzinger): This should be a THREADED_TEST but causes failures
-// on the buildbots, so was made non-threaded for the time being.
-TEST(ApiObjectGroupsCycleForScavenger) {
- i::FLAG_stress_compaction = false;
- i::FLAG_gc_global = false;
- LocalContext env;
- v8::Isolate* iso = env->GetIsolate();
- HandleScope scope(iso);
-
- WeakCallCounter counter(1234);
-
- WeakCallCounterAndPersistent<Value> g1s1(&counter);
- WeakCallCounterAndPersistent<Value> g1s2(&counter);
- WeakCallCounterAndPersistent<Value> g2s1(&counter);
- WeakCallCounterAndPersistent<Value> g2s2(&counter);
- WeakCallCounterAndPersistent<Value> g3s1(&counter);
- WeakCallCounterAndPersistent<Value> g3s2(&counter);
-
- {
- HandleScope scope(iso);
- g1s1.handle.Reset(iso, Object::New(iso));
- g1s2.handle.Reset(iso, Object::New(iso));
- g1s1.handle.SetWeak(&g1s1, &WeakPointerCallback,
- v8::WeakCallbackType::kParameter);
- g1s2.handle.SetWeak(&g1s2, &WeakPointerCallback,
- v8::WeakCallbackType::kParameter);
-
- g2s1.handle.Reset(iso, Object::New(iso));
- g2s2.handle.Reset(iso, Object::New(iso));
- g2s1.handle.SetWeak(&g2s1, &WeakPointerCallback,
- v8::WeakCallbackType::kParameter);
- g2s2.handle.SetWeak(&g2s2, &WeakPointerCallback,
- v8::WeakCallbackType::kParameter);
-
- g3s1.handle.Reset(iso, Object::New(iso));
- g3s2.handle.Reset(iso, Object::New(iso));
- g3s1.handle.SetWeak(&g3s1, &WeakPointerCallback,
- v8::WeakCallbackType::kParameter);
- g3s2.handle.SetWeak(&g3s2, &WeakPointerCallback,
- v8::WeakCallbackType::kParameter);
- }
-
- // Make a root.
- WeakCallCounterAndPersistent<Value> root(&counter);
- root.handle.Reset(iso, g1s1.handle);
- root.handle.MarkPartiallyDependent();
-
- // Connect groups. We're building the following cycle:
- // G1: { g1s1, g2s1 }, g1s1 implicitly references g2s1, ditto for other
- // groups.
- {
- HandleScope handle_scope(iso);
- g1s1.handle.MarkPartiallyDependent();
- g1s2.handle.MarkPartiallyDependent();
- g2s1.handle.MarkPartiallyDependent();
- g2s2.handle.MarkPartiallyDependent();
- g3s1.handle.MarkPartiallyDependent();
- g3s2.handle.MarkPartiallyDependent();
- iso->SetObjectGroupId(g1s1.handle, UniqueId(1));
- iso->SetObjectGroupId(g1s2.handle, UniqueId(1));
- Local<Object>::New(iso, g1s1.handle.As<Object>())
- ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g2s1.handle))
- .FromJust();
- iso->SetObjectGroupId(g2s1.handle, UniqueId(2));
- iso->SetObjectGroupId(g2s2.handle, UniqueId(2));
- Local<Object>::New(iso, g2s1.handle.As<Object>())
- ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g3s1.handle))
- .FromJust();
- iso->SetObjectGroupId(g3s1.handle, UniqueId(3));
- iso->SetObjectGroupId(g3s2.handle, UniqueId(3));
- Local<Object>::New(iso, g3s1.handle.As<Object>())
- ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g1s1.handle))
- .FromJust();
- }
-
- v8::internal::Heap* heap =
- reinterpret_cast<v8::internal::Isolate*>(iso)->heap();
- heap->CollectAllGarbage();
-
- // All objects should be alive.
- CHECK_EQ(0, counter.NumberOfWeakCalls());
-
- // Weaken the root.
- root.handle.SetWeak(&root, &WeakPointerCallback,
- v8::WeakCallbackType::kParameter);
- root.handle.MarkPartiallyDependent();
-
- // Groups are deleted, rebuild groups.
- {
- HandleScope handle_scope(iso);
- g1s1.handle.MarkPartiallyDependent();
- g1s2.handle.MarkPartiallyDependent();
- g2s1.handle.MarkPartiallyDependent();
- g2s2.handle.MarkPartiallyDependent();
- g3s1.handle.MarkPartiallyDependent();
- g3s2.handle.MarkPartiallyDependent();
- iso->SetObjectGroupId(g1s1.handle, UniqueId(1));
- iso->SetObjectGroupId(g1s2.handle, UniqueId(1));
- Local<Object>::New(iso, g1s1.handle.As<Object>())
- ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g2s1.handle))
- .FromJust();
- iso->SetObjectGroupId(g2s1.handle, UniqueId(2));
- iso->SetObjectGroupId(g2s2.handle, UniqueId(2));
- Local<Object>::New(iso, g2s1.handle.As<Object>())
- ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g3s1.handle))
- .FromJust();
- iso->SetObjectGroupId(g3s1.handle, UniqueId(3));
- iso->SetObjectGroupId(g3s2.handle, UniqueId(3));
- Local<Object>::New(iso, g3s1.handle.As<Object>())
- ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g1s1.handle))
- .FromJust();
- }
-
- heap->CollectAllGarbage();
-
- // All objects should be gone. 7 global handles in total.
- CHECK_EQ(7, counter.NumberOfWeakCalls());
-}
-
-
THREADED_TEST(ScriptException) {
LocalContext env;
v8::HandleScope scope(env->GetIsolate());
@@ -6511,6 +6480,46 @@
CHECK(!v8::False(isolate)->SameValue(v8::Undefined(isolate)));
}
+THREADED_TEST(TypeOf) {
+ LocalContext context;
+ v8::Isolate* isolate = context->GetIsolate();
+ v8::HandleScope scope(context->GetIsolate());
+
+ Local<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New(isolate);
+ Local<v8::Function> fun = t1->GetFunction(context.local()).ToLocalChecked();
+
+ CHECK(v8::Undefined(isolate)
+ ->TypeOf(isolate)
+ ->Equals(context.local(), v8_str("undefined"))
+ .FromJust());
+ CHECK(v8::Null(isolate)
+ ->TypeOf(isolate)
+ ->Equals(context.local(), v8_str("object"))
+ .FromJust());
+ CHECK(v8_str("str")
+ ->TypeOf(isolate)
+ ->Equals(context.local(), v8_str("string"))
+ .FromJust());
+ CHECK(v8_num(0.0)
+ ->TypeOf(isolate)
+ ->Equals(context.local(), v8_str("number"))
+ .FromJust());
+ CHECK(v8_num(1)
+ ->TypeOf(isolate)
+ ->Equals(context.local(), v8_str("number"))
+ .FromJust());
+ CHECK(v8::Object::New(isolate)
+ ->TypeOf(isolate)
+ ->Equals(context.local(), v8_str("object"))
+ .FromJust());
+ CHECK(v8::Boolean::New(isolate, true)
+ ->TypeOf(isolate)
+ ->Equals(context.local(), v8_str("boolean"))
+ .FromJust());
+ CHECK(fun->TypeOf(isolate)
+ ->Equals(context.local(), v8_str("function"))
+ .FromJust());
+}
THREADED_TEST(MultiRun) {
LocalContext context;
@@ -9046,33 +9055,6 @@
}
-TEST(ApiUncaughtExceptionInObjectObserve) {
- v8::internal::FLAG_harmony_object_observe = true;
- v8::internal::FLAG_stack_size = 150;
- report_count = 0;
- LocalContext env;
- v8::Isolate* isolate = env->GetIsolate();
- v8::HandleScope scope(isolate);
- isolate->AddMessageListener(ApiUncaughtExceptionTestListener);
- CompileRun(
- "var obj = {};"
- "var observe_count = 0;"
- "function observer1() { ++observe_count; };"
- "function observer2() { ++observe_count; };"
- "function observer_throws() { throw new Error(); };"
- "function stack_overflow() { return (function f(x) { f(x+1); })(0); };"
- "Object.observe(obj, observer_throws.bind());"
- "Object.observe(obj, observer1);"
- "Object.observe(obj, stack_overflow);"
- "Object.observe(obj, observer2);"
- "Object.observe(obj, observer_throws.bind());"
- "obj.foo = 'bar';");
- CHECK_EQ(3, report_count);
- ExpectInt32("observe_count", 2);
- isolate->RemoveMessageListeners(ApiUncaughtExceptionTestListener);
-}
-
-
static const char* script_resource_name = "ExceptionInNativeScript.js";
static void ExceptionInNativeScriptTestListener(v8::Local<v8::Message> message,
v8::Local<Value>) {
@@ -10541,6 +10523,69 @@
}
}
+THREADED_TEST(ObjectGetOwnPropertyNames) {
+ LocalContext context;
+ v8::Isolate* isolate = context->GetIsolate();
+ v8::HandleScope handle_scope(isolate);
+
+ v8::Local<v8::Object> value =
+ v8::Local<v8::Object>::Cast(v8::StringObject::New(v8_str("test")));
+ v8::Local<v8::Array> properties;
+
+ CHECK(value
+ ->GetOwnPropertyNames(context.local(),
+ static_cast<v8::PropertyFilter>(
+ v8::PropertyFilter::ALL_PROPERTIES |
+ v8::PropertyFilter::SKIP_SYMBOLS))
+ .ToLocal(&properties));
+ CHECK_EQ(5, properties->Length());
+ v8::Local<v8::Value> property;
+ CHECK(properties->Get(context.local(), 4).ToLocal(&property) &&
+ property->IsString());
+ CHECK(property.As<v8::String>()
+ ->Equals(context.local(), v8_str("length"))
+ .FromMaybe(false));
+ for (int i = 0; i < 4; ++i) {
+ v8::Local<v8::Value> property;
+ CHECK(properties->Get(context.local(), i).ToLocal(&property) &&
+ property->IsInt32());
+ CHECK_EQ(property.As<v8::Int32>()->Value(), i);
+ }
+
+ CHECK(value->GetOwnPropertyNames(context.local(), v8::ONLY_ENUMERABLE)
+ .ToLocal(&properties));
+ CHECK_EQ(4, properties->Length());
+ for (int i = 0; i < 4; ++i) {
+ v8::Local<v8::Value> property;
+ CHECK(properties->Get(context.local(), i).ToLocal(&property) &&
+ property->IsInt32());
+ CHECK_EQ(property.As<v8::Int32>()->Value(), i);
+ }
+
+ value = value->GetPrototype().As<v8::Object>();
+ CHECK(value
+ ->GetOwnPropertyNames(context.local(),
+ static_cast<v8::PropertyFilter>(
+ v8::PropertyFilter::ALL_PROPERTIES |
+ v8::PropertyFilter::SKIP_SYMBOLS))
+ .ToLocal(&properties));
+ bool concat_found = false;
+ bool starts_with_found = false;
+ for (uint32_t i = 0; i < properties->Length(); ++i) {
+ v8::Local<v8::Value> property;
+ CHECK(properties->Get(context.local(), i).ToLocal(&property));
+ if (!property->IsString()) continue;
+ if (!concat_found)
+ concat_found = property.As<v8::String>()
+ ->Equals(context.local(), v8_str("concat"))
+ .FromMaybe(false);
+ if (!starts_with_found)
+ starts_with_found = property.As<v8::String>()
+ ->Equals(context.local(), v8_str("startsWith"))
+ .FromMaybe(false);
+ }
+ CHECK(concat_found && starts_with_found);
+}
THREADED_TEST(CallKnownGlobalReceiver) {
v8::Isolate* isolate = CcTest::isolate();
@@ -11185,6 +11230,7 @@
Local<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New(isolate);
t1->RemovePrototype();
Local<v8::Function> fun = t1->GetFunction(context.local()).ToLocalChecked();
+ CHECK(!fun->IsConstructor());
CHECK(context->Global()->Set(context.local(), v8_str("fun"), fun).FromJust());
CHECK(!CompileRun("'prototype' in fun")
->BooleanValue(context.local())
@@ -13261,6 +13307,43 @@
CHECK(value->BooleanValue(context.local()).FromJust());
}
+static void NewTargetHandler(const v8::FunctionCallbackInfo<v8::Value>& args) {
+ ApiTestFuzzer::Fuzz();
+ args.GetReturnValue().Set(args.NewTarget());
+}
+
+THREADED_TEST(NewTargetHandler) {
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope scope(isolate);
+
+ // Function template with call handler.
+ Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
+ templ->SetCallHandler(NewTargetHandler);
+
+ LocalContext context;
+
+ Local<Function> function =
+ templ->GetFunction(context.local()).ToLocalChecked();
+ CHECK(context->Global()
+ ->Set(context.local(), v8_str("f"), function)
+ .FromJust());
+ Local<Value> value = CompileRun("f()");
+ CHECK(value->IsUndefined());
+ value = CompileRun("new f()");
+ CHECK(value->IsFunction());
+ CHECK(value == function);
+ Local<Value> subclass = CompileRun("var g = class extends f { }; g");
+ CHECK(subclass->IsFunction());
+ value = CompileRun("new g()");
+ CHECK(value->IsFunction());
+ CHECK(value == subclass);
+ value = CompileRun("Reflect.construct(f, [], Array)");
+ CHECK(value->IsFunction());
+ CHECK(value ==
+ context->Global()
+ ->Get(context.local(), v8_str("Array"))
+ .ToLocalChecked());
+}
THREADED_TEST(ObjectProtoToString) {
v8::Isolate* isolate = CcTest::isolate();
@@ -14416,7 +14499,6 @@
return invocations;
}
-
void SetFunctionEntryHookTest::RunLoopInNewEnv(v8::Isolate* isolate) {
v8::HandleScope outer(isolate);
v8::Local<Context> env = Context::New(isolate);
@@ -14474,10 +14556,19 @@
RunLoopInNewEnv(isolate);
- // Check the exepected invocation counts.
- CHECK_EQ(2, CountInvocations(NULL, "bar"));
- CHECK_EQ(200, CountInvocations("bar", "foo"));
- CHECK_EQ(200, CountInvocations(NULL, "foo"));
+ // Check the expected invocation counts.
+ if (!i::FLAG_ignition) {
+ CHECK_EQ(2, CountInvocations(NULL, "bar"));
+ CHECK_EQ(200, CountInvocations("bar", "foo"));
+ CHECK_EQ(200, CountInvocations(NULL, "foo"));
+ } else {
+ // For ignition we don't see the actual functions being called, instead
+ // we see the IterpreterEntryTrampoline at least 102 times
+ // (100 unoptimized calls to foo, and 2 calls to bar).
+ CHECK_LE(102, CountInvocations(NULL, "InterpreterEntryTrampoline"));
+ // We should also see the calls to the optimized function foo.
+ CHECK_EQ(100, CountInvocations(NULL, "foo"));
+ }
// Verify that we have an entry hook on some specific stubs.
CHECK_NE(0, CountInvocations(NULL, "CEntryStub"));
@@ -18728,12 +18819,6 @@
}
-static void NamedPropertyGetterWhichReturns42(
- Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
- info.GetReturnValue().Set(v8_num(42));
-}
-
-
static void NamedPropertySetterWhichSetsYOnThisTo23(
Local<Name> name, Local<Value> value,
const v8::PropertyCallbackInfo<v8::Value>& info) {
@@ -20313,6 +20398,7 @@
HasOwnPropertyNamedPropertyGetter));
Local<Object> instance = templ->NewInstance(env.local()).ToLocalChecked();
CHECK(!instance->HasOwnProperty(env.local(), v8_str("42")).FromJust());
+ CHECK(!instance->HasOwnProperty(env.local(), 42).FromJust());
CHECK(instance->HasOwnProperty(env.local(), v8_str("foo")).FromJust());
CHECK(!instance->HasOwnProperty(env.local(), v8_str("bar")).FromJust());
}
@@ -20322,7 +20408,9 @@
HasOwnPropertyIndexedPropertyGetter));
Local<Object> instance = templ->NewInstance(env.local()).ToLocalChecked();
CHECK(instance->HasOwnProperty(env.local(), v8_str("42")).FromJust());
+ CHECK(instance->HasOwnProperty(env.local(), 42).FromJust());
CHECK(!instance->HasOwnProperty(env.local(), v8_str("43")).FromJust());
+ CHECK(!instance->HasOwnProperty(env.local(), 43).FromJust());
CHECK(!instance->HasOwnProperty(env.local(), v8_str("foo")).FromJust());
}
{ // Check named query interceptors.
@@ -20339,7 +20427,9 @@
0, 0, HasOwnPropertyIndexedPropertyQuery));
Local<Object> instance = templ->NewInstance(env.local()).ToLocalChecked();
CHECK(instance->HasOwnProperty(env.local(), v8_str("42")).FromJust());
+ CHECK(instance->HasOwnProperty(env.local(), 42).FromJust());
CHECK(!instance->HasOwnProperty(env.local(), v8_str("41")).FromJust());
+ CHECK(!instance->HasOwnProperty(env.local(), 41).FromJust());
}
{ // Check callbacks.
Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
@@ -20917,6 +21007,7 @@
static void MicrotaskOne(const v8::FunctionCallbackInfo<Value>& info) {
+ CHECK(v8::MicrotasksScope::IsRunningMicrotasks(info.GetIsolate()));
v8::HandleScope scope(info.GetIsolate());
v8::MicrotasksScope microtasks(info.GetIsolate(),
v8::MicrotasksScope::kDoNotRunMicrotasks);
@@ -20925,6 +21016,7 @@
static void MicrotaskTwo(const v8::FunctionCallbackInfo<Value>& info) {
+ CHECK(v8::MicrotasksScope::IsRunningMicrotasks(info.GetIsolate()));
v8::HandleScope scope(info.GetIsolate());
v8::MicrotasksScope microtasks(info.GetIsolate(),
v8::MicrotasksScope::kDoNotRunMicrotasks);
@@ -20943,6 +21035,7 @@
TEST(EnqueueMicrotask) {
LocalContext env;
v8::HandleScope scope(env->GetIsolate());
+ CHECK(!v8::MicrotasksScope::IsRunningMicrotasks(env->GetIsolate()));
CompileRun(
"var ext1Calls = 0;"
"var ext2Calls = 0;");
@@ -21283,40 +21376,6 @@
}
-static void DebugEventInObserver(const v8::Debug::EventDetails& event_details) {
- v8::DebugEvent event = event_details.GetEvent();
- if (event != v8::Break) return;
- Local<Object> exec_state = event_details.GetExecutionState();
- Local<Context> context = CcTest::isolate()->GetCurrentContext();
- Local<Value> break_id =
- exec_state->Get(context, v8_str("break_id")).ToLocalChecked();
- CompileRun("function f(id) { new FrameDetails(id, 0); }");
- Local<Function> fun = Local<Function>::Cast(
- CcTest::global()->Get(context, v8_str("f")).ToLocalChecked());
- fun->Call(context, CcTest::global(), 1, &break_id).ToLocalChecked();
-}
-
-
-TEST(Regress385349) {
- i::FLAG_harmony_object_observe = true;
- i::FLAG_allow_natives_syntax = true;
- v8::Isolate* isolate = CcTest::isolate();
- HandleScope handle_scope(isolate);
- isolate->SetMicrotasksPolicy(v8::MicrotasksPolicy::kExplicit);
- Local<Context> context = Context::New(isolate);
- v8::Debug::SetDebugEventListener(isolate, DebugEventInObserver);
- {
- Context::Scope context_scope(context);
- CompileRun("var obj = {};"
- "Object.observe(obj, function(changes) { debugger; });"
- "obj.a = 0;");
- }
- isolate->RunMicrotasks();
- isolate->SetMicrotasksPolicy(v8::MicrotasksPolicy::kAuto);
- v8::Debug::SetDebugEventListener(isolate, nullptr);
-}
-
-
#ifdef ENABLE_DISASSEMBLER
static int probes_counter = 0;
static int misses_counter = 0;
@@ -21960,29 +22019,39 @@
CHECK(function->IsFunction());
}
-
THREADED_TEST(JSONParseObject) {
LocalContext context;
HandleScope scope(context->GetIsolate());
Local<Value> obj =
- v8::JSON::Parse(context->GetIsolate(), v8_str("{\"x\":42}"))
- .ToLocalChecked();
+ v8::JSON::Parse(context.local(), v8_str("{\"x\":42}")).ToLocalChecked();
Local<Object> global = context->Global();
global->Set(context.local(), v8_str("obj"), obj).FromJust();
ExpectString("JSON.stringify(obj)", "{\"x\":42}");
}
-
THREADED_TEST(JSONParseNumber) {
LocalContext context;
HandleScope scope(context->GetIsolate());
Local<Value> obj =
- v8::JSON::Parse(context->GetIsolate(), v8_str("42")).ToLocalChecked();
+ v8::JSON::Parse(context.local(), v8_str("42")).ToLocalChecked();
Local<Object> global = context->Global();
global->Set(context.local(), v8_str("obj"), obj).FromJust();
ExpectString("JSON.stringify(obj)", "42");
}
+THREADED_TEST(JSONStringifyObject) {
+ LocalContext context;
+ HandleScope scope(context->GetIsolate());
+ Local<Value> value =
+ v8::JSON::Parse(context.local(), v8_str("{\"x\":42}")).ToLocalChecked();
+ Local<Object> obj = value->ToObject(context.local()).ToLocalChecked();
+ Local<Object> global = context->Global();
+ global->Set(context.local(), v8_str("obj"), obj).FromJust();
+ Local<String> json =
+ v8::JSON::Stringify(context.local(), obj).ToLocalChecked();
+ v8::String::Utf8Value utf8(json);
+ ExpectString("JSON.stringify(obj)", *utf8);
+}
#if V8_OS_POSIX && !V8_OS_NACL
class ThreadInterruptTest {
@@ -24077,8 +24146,7 @@
script->Run(context).ToLocalChecked()->Int32Value(context).FromJust());
}
-
-TEST(InvalidCacheData) {
+TEST(InvalidParserCacheData) {
v8::V8::Initialize();
v8::HandleScope scope(CcTest::isolate());
LocalContext context;
@@ -24086,6 +24154,12 @@
// Cached parser data is not consumed while parsing eagerly.
TestInvalidCacheData(v8::ScriptCompiler::kConsumeParserCache);
}
+}
+
+TEST(InvalidCodeCacheData) {
+ v8::V8::Initialize();
+ v8::HandleScope scope(CcTest::isolate());
+ LocalContext context;
TestInvalidCacheData(v8::ScriptCompiler::kConsumeCodeCache);
}
@@ -24168,6 +24242,7 @@
TEST(TurboAsmDisablesNeuter) {
+ i::FLAG_allow_natives_syntax = true;
v8::V8::Initialize();
v8::HandleScope scope(CcTest::isolate());
LocalContext context;
@@ -24180,10 +24255,11 @@
" return { load: load };"
"}"
"var buffer = new ArrayBuffer(4);"
- "Module(this, {}, buffer).load();"
+ "var module = Module(this, {}, buffer);"
+ "%OptimizeFunctionOnNextCall(module.load);"
+ "module.load();"
"buffer";
- i::FLAG_turbo_osr = false; // TODO(titzer): test requires eager TF.
v8::Local<v8::ArrayBuffer> result = CompileRun(load).As<v8::ArrayBuffer>();
CHECK_EQ(should_be_neuterable, result->IsNeuterable());
@@ -24195,10 +24271,11 @@
" return { store: store };"
"}"
"var buffer = new ArrayBuffer(4);"
- "Module(this, {}, buffer).store();"
+ "var module = Module(this, {}, buffer);"
+ "%OptimizeFunctionOnNextCall(module.store);"
+ "module.store();"
"buffer";
- i::FLAG_turbo_osr = false; // TODO(titzer): test requires eager TF.
result = CompileRun(store).As<v8::ArrayBuffer>();
CHECK_EQ(should_be_neuterable, result->IsNeuterable());
}
@@ -24629,6 +24706,60 @@
CHECK_EQ(0U, set->Size());
}
+TEST(SetDeleteThenAsArray) {
+ // https://bugs.chromium.org/p/v8/issues/detail?id=4946
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope handle_scope(isolate);
+ LocalContext env;
+
+ // make a Set
+ v8::Local<v8::Value> val = CompileRun("new Set([1, 2, 3])");
+ v8::Local<v8::Set> set = v8::Local<v8::Set>::Cast(val);
+ CHECK_EQ(3U, set->Size());
+
+ // delete the "middle" element (using AsArray to
+ // determine which element is the "middle" element)
+ v8::Local<v8::Array> array1 = set->AsArray();
+ CHECK_EQ(3U, array1->Length());
+ CHECK(set->Delete(env.local(), array1->Get(env.local(), 1).ToLocalChecked())
+ .FromJust());
+
+ // make sure there are no undefined values when we convert to an array again.
+ v8::Local<v8::Array> array2 = set->AsArray();
+ uint32_t length = array2->Length();
+ CHECK_EQ(2U, length);
+ for (uint32_t i = 0; i < length; i++) {
+ CHECK(!array2->Get(env.local(), i).ToLocalChecked()->IsUndefined());
+ }
+}
+
+TEST(MapDeleteThenAsArray) {
+ // https://bugs.chromium.org/p/v8/issues/detail?id=4946
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope handle_scope(isolate);
+ LocalContext env;
+
+ // make a Map
+ v8::Local<v8::Value> val = CompileRun("new Map([[1, 2], [3, 4], [5, 6]])");
+ v8::Local<v8::Map> map = v8::Local<v8::Map>::Cast(val);
+ CHECK_EQ(3U, map->Size());
+
+ // delete the "middle" element (using AsArray to
+ // determine which element is the "middle" element)
+ v8::Local<v8::Array> array1 = map->AsArray();
+ CHECK_EQ(6U, array1->Length());
+ // Map::AsArray returns a flat array, so the second key is at index 2.
+ v8::Local<v8::Value> key = array1->Get(env.local(), 2).ToLocalChecked();
+ CHECK(map->Delete(env.local(), key).FromJust());
+
+ // make sure there are no undefined values when we convert to an array again.
+ v8::Local<v8::Array> array2 = map->AsArray();
+ uint32_t length = array2->Length();
+ CHECK_EQ(4U, length);
+ for (uint32_t i = 0; i < length; i++) {
+ CHECK(!array2->Get(env.local(), i).ToLocalChecked()->IsUndefined());
+ }
+}
TEST(CompatibleReceiverCheckOnCachedICHandler) {
v8::Isolate* isolate = CcTest::isolate();
diff --git a/test/cctest/test-asm-validator.cc b/test/cctest/test-asm-validator.cc
index d5b5179..a07eecf 100644
--- a/test/cctest/test-asm-validator.cc
+++ b/test/cctest/test-asm-validator.cc
@@ -61,7 +61,6 @@
i::ParseInfo info(zone, script);
i::Parser parser(&info);
- parser.set_allow_harmony_sloppy(true);
info.set_global();
info.set_lazy(false);
info.set_allow_lazy_parsing(false);
@@ -73,7 +72,7 @@
info.scope()->declarations()->at(0)->AsFunctionDeclaration()->fun();
AsmTyper typer(isolate, zone, *script, root);
if (typer.Validate()) {
- ExpressionTypeCollector(isolate, root, types).Run();
+ ExpressionTypeCollector(isolate, root, typer.bounds(), types).Run();
return "";
} else {
return typer.error_message();
@@ -1801,14 +1800,10 @@
TEST(InstanceOf) {
- const char* errorMsg = FLAG_harmony_instanceof
- ? "asm: line 0: do-expression encountered\n"
- : "asm: line 1: illegal comparison operator\n";
-
CHECK_FUNC_ERROR(
"function bar() { return (0 instanceof 0)|0; }\n"
"function foo() { bar(); }",
- errorMsg);
+ "asm: line 1: illegal comparison operator\n");
}
diff --git a/test/cctest/test-assembler-arm.cc b/test/cctest/test-assembler-arm.cc
index 3763f06..cf404b0 100644
--- a/test/cctest/test-assembler-arm.cc
+++ b/test/cctest/test-assembler-arm.cc
@@ -412,29 +412,26 @@
Assembler assm(isolate, NULL, 0);
- if (CpuFeatures::IsSupported(ARMv7)) {
- CpuFeatureScope scope(&assm, ARMv7);
- __ usat(r1, 8, Operand(r0)); // Sat 0xFFFF to 0-255 = 0xFF.
- __ usat(r2, 12, Operand(r0, ASR, 9)); // Sat (0xFFFF>>9) to 0-4095 = 0x7F.
- __ usat(r3, 1, Operand(r0, LSL, 16)); // Sat (0xFFFF<<16) to 0-1 = 0x0.
- __ add(r0, r1, Operand(r2));
- __ add(r0, r0, Operand(r3));
- __ mov(pc, Operand(lr));
+ __ usat(r1, 8, Operand(r0)); // Sat 0xFFFF to 0-255 = 0xFF.
+ __ usat(r2, 12, Operand(r0, ASR, 9)); // Sat (0xFFFF>>9) to 0-4095 = 0x7F.
+ __ usat(r3, 1, Operand(r0, LSL, 16)); // Sat (0xFFFF<<16) to 0-1 = 0x0.
+ __ add(r0, r1, Operand(r2));
+ __ add(r0, r0, Operand(r3));
+ __ mov(pc, Operand(lr));
- CodeDesc desc;
- assm.GetCode(&desc);
- Handle<Code> code = isolate->factory()->NewCode(
- desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
#ifdef DEBUG
- OFStream os(stdout);
- code->Print(os);
+ OFStream os(stdout);
+ code->Print(os);
#endif
- F1 f = FUNCTION_CAST<F1>(code->entry());
- int res = reinterpret_cast<int>(
- CALL_GENERATED_CODE(isolate, f, 0xFFFF, 0, 0, 0, 0));
- ::printf("f() = %d\n", res);
- CHECK_EQ(382, res);
- }
+ F1 f = FUNCTION_CAST<F1>(code->entry());
+ int res = reinterpret_cast<int>(
+ CALL_GENERATED_CODE(isolate, f, 0xFFFF, 0, 0, 0, 0));
+ ::printf("f() = %d\n", res);
+ CHECK_EQ(382, res);
}
@@ -2231,6 +2228,158 @@
}
}
+TEST(ARMv8_vsel) {
+ // Test the vsel floating point instructions.
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+
+ Assembler assm(isolate, NULL, 0);
+
+ // Used to indicate whether a condition passed or failed.
+ static constexpr float kResultPass = 1.0f;
+ static constexpr float kResultFail = -kResultPass;
+
+ struct ResultsF32 {
+ float vseleq_;
+ float vselge_;
+ float vselgt_;
+ float vselvs_;
+
+ // The following conditions aren't architecturally supported, but the
+ // assembler implements them by swapping the inputs.
+ float vselne_;
+ float vsellt_;
+ float vselle_;
+ float vselvc_;
+ };
+
+ struct ResultsF64 {
+ double vseleq_;
+ double vselge_;
+ double vselgt_;
+ double vselvs_;
+
+ // The following conditions aren't architecturally supported, but the
+ // assembler implements them by swapping the inputs.
+ double vselne_;
+ double vsellt_;
+ double vselle_;
+ double vselvc_;
+ };
+
+ if (CpuFeatures::IsSupported(ARMv8)) {
+ CpuFeatureScope scope(&assm, ARMv8);
+
+ // Create a helper function:
+ // void TestVsel(uint32_t nzcv,
+ // ResultsF32* results_f32,
+ // ResultsF64* results_f64);
+ __ msr(CPSR_f, Operand(r0));
+
+ __ vmov(s1, kResultPass);
+ __ vmov(s2, kResultFail);
+
+ __ vsel(eq, s0, s1, s2);
+ __ vstr(s0, r1, offsetof(ResultsF32, vseleq_));
+ __ vsel(ge, s0, s1, s2);
+ __ vstr(s0, r1, offsetof(ResultsF32, vselge_));
+ __ vsel(gt, s0, s1, s2);
+ __ vstr(s0, r1, offsetof(ResultsF32, vselgt_));
+ __ vsel(vs, s0, s1, s2);
+ __ vstr(s0, r1, offsetof(ResultsF32, vselvs_));
+
+ __ vsel(ne, s0, s1, s2);
+ __ vstr(s0, r1, offsetof(ResultsF32, vselne_));
+ __ vsel(lt, s0, s1, s2);
+ __ vstr(s0, r1, offsetof(ResultsF32, vsellt_));
+ __ vsel(le, s0, s1, s2);
+ __ vstr(s0, r1, offsetof(ResultsF32, vselle_));
+ __ vsel(vc, s0, s1, s2);
+ __ vstr(s0, r1, offsetof(ResultsF32, vselvc_));
+
+ __ vmov(d1, kResultPass);
+ __ vmov(d2, kResultFail);
+
+ __ vsel(eq, d0, d1, d2);
+ __ vstr(d0, r2, offsetof(ResultsF64, vseleq_));
+ __ vsel(ge, d0, d1, d2);
+ __ vstr(d0, r2, offsetof(ResultsF64, vselge_));
+ __ vsel(gt, d0, d1, d2);
+ __ vstr(d0, r2, offsetof(ResultsF64, vselgt_));
+ __ vsel(vs, d0, d1, d2);
+ __ vstr(d0, r2, offsetof(ResultsF64, vselvs_));
+
+ __ vsel(ne, d0, d1, d2);
+ __ vstr(d0, r2, offsetof(ResultsF64, vselne_));
+ __ vsel(lt, d0, d1, d2);
+ __ vstr(d0, r2, offsetof(ResultsF64, vsellt_));
+ __ vsel(le, d0, d1, d2);
+ __ vstr(d0, r2, offsetof(ResultsF64, vselle_));
+ __ vsel(vc, d0, d1, d2);
+ __ vstr(d0, r2, offsetof(ResultsF64, vselvc_));
+
+ __ bx(lr);
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+#ifdef DEBUG
+ OFStream os(stdout);
+ code->Print(os);
+#endif
+ F5 f = FUNCTION_CAST<F5>(code->entry());
+ Object* dummy = nullptr;
+ USE(dummy);
+
+ STATIC_ASSERT(kResultPass == -kResultFail);
+#define CHECK_VSEL(n, z, c, v, vseleq, vselge, vselgt, vselvs) \
+ do { \
+ ResultsF32 results_f32; \
+ ResultsF64 results_f64; \
+ uint32_t nzcv = (n << 31) | (z << 30) | (c << 29) | (v << 28); \
+ dummy = CALL_GENERATED_CODE(isolate, f, nzcv, &results_f32, &results_f64, \
+ 0, 0); \
+ CHECK_EQ(vseleq, results_f32.vseleq_); \
+ CHECK_EQ(vselge, results_f32.vselge_); \
+ CHECK_EQ(vselgt, results_f32.vselgt_); \
+ CHECK_EQ(vselvs, results_f32.vselvs_); \
+ CHECK_EQ(-vseleq, results_f32.vselne_); \
+ CHECK_EQ(-vselge, results_f32.vsellt_); \
+ CHECK_EQ(-vselgt, results_f32.vselle_); \
+ CHECK_EQ(-vselvs, results_f32.vselvc_); \
+ CHECK_EQ(vseleq, results_f64.vseleq_); \
+ CHECK_EQ(vselge, results_f64.vselge_); \
+ CHECK_EQ(vselgt, results_f64.vselgt_); \
+ CHECK_EQ(vselvs, results_f64.vselvs_); \
+ CHECK_EQ(-vseleq, results_f64.vselne_); \
+ CHECK_EQ(-vselge, results_f64.vsellt_); \
+ CHECK_EQ(-vselgt, results_f64.vselle_); \
+ CHECK_EQ(-vselvs, results_f64.vselvc_); \
+ } while (0);
+
+ // N Z C V vseleq vselge vselgt vselvs
+ CHECK_VSEL(0, 0, 0, 0, kResultFail, kResultPass, kResultPass, kResultFail);
+ CHECK_VSEL(0, 0, 0, 1, kResultFail, kResultFail, kResultFail, kResultPass);
+ CHECK_VSEL(0, 0, 1, 0, kResultFail, kResultPass, kResultPass, kResultFail);
+ CHECK_VSEL(0, 0, 1, 1, kResultFail, kResultFail, kResultFail, kResultPass);
+ CHECK_VSEL(0, 1, 0, 0, kResultPass, kResultPass, kResultFail, kResultFail);
+ CHECK_VSEL(0, 1, 0, 1, kResultPass, kResultFail, kResultFail, kResultPass);
+ CHECK_VSEL(0, 1, 1, 0, kResultPass, kResultPass, kResultFail, kResultFail);
+ CHECK_VSEL(0, 1, 1, 1, kResultPass, kResultFail, kResultFail, kResultPass);
+ CHECK_VSEL(1, 0, 0, 0, kResultFail, kResultFail, kResultFail, kResultFail);
+ CHECK_VSEL(1, 0, 0, 1, kResultFail, kResultPass, kResultPass, kResultPass);
+ CHECK_VSEL(1, 0, 1, 0, kResultFail, kResultFail, kResultFail, kResultFail);
+ CHECK_VSEL(1, 0, 1, 1, kResultFail, kResultPass, kResultPass, kResultPass);
+ CHECK_VSEL(1, 1, 0, 0, kResultPass, kResultFail, kResultFail, kResultFail);
+ CHECK_VSEL(1, 1, 0, 1, kResultPass, kResultPass, kResultFail, kResultPass);
+ CHECK_VSEL(1, 1, 1, 0, kResultPass, kResultFail, kResultFail, kResultFail);
+ CHECK_VSEL(1, 1, 1, 1, kResultPass, kResultPass, kResultFail, kResultPass);
+
+#undef CHECK_VSEL
+ }
+}
TEST(regress4292_b) {
CcTest::InitializeVM();
diff --git a/test/cctest/test-assembler-ia32.cc b/test/cctest/test-assembler-ia32.cc
index 12733c2..e4cac56 100644
--- a/test/cctest/test-assembler-ia32.cc
+++ b/test/cctest/test-assembler-ia32.cc
@@ -1497,4 +1497,45 @@
}
}
+TEST(Regress621926) {
+ // Bug description:
+ // The opcodes for cmpw r/m16, r16 and cmpw r16, r/m16 were swapped.
+ // This was causing non-commutative comparisons to produce the wrong result.
+ CcTest::InitializeVM();
+ Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());
+ HandleScope scope(isolate);
+ Assembler assm(isolate, nullptr, 0);
+
+ uint16_t a = 42;
+
+ Label fail;
+ __ push(ebx);
+ __ mov(ebx, Immediate(reinterpret_cast<intptr_t>(&a)));
+ __ mov(eax, Immediate(41));
+ __ cmpw(eax, Operand(ebx, 0));
+ __ j(above_equal, &fail);
+ __ cmpw(Operand(ebx, 0), eax);
+ __ j(below_equal, &fail);
+ __ mov(eax, 1);
+ __ pop(ebx);
+ __ ret(0);
+ __ bind(&fail);
+ __ mov(eax, 0);
+ __ pop(ebx);
+ __ ret(0);
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+#ifdef OBJECT_PRINT
+ OFStream os(stdout);
+ code->Print(os);
+#endif
+
+ F0 f = FUNCTION_CAST<F0>(code->entry());
+ CHECK_EQ(f(), 1);
+}
+
#undef __
diff --git a/test/cctest/test-assembler-mips.cc b/test/cctest/test-assembler-mips.cc
index b8a0426..e73b40e 100644
--- a/test/cctest/test-assembler-mips.cc
+++ b/test/cctest/test-assembler-mips.cc
@@ -2048,7 +2048,7 @@
v8::internal::CodeObjectRequired::kYes);
typedef struct test_float {
- int64_t rt;
+ int32_t rt;
double a;
double b;
double bold;
@@ -3191,6 +3191,8 @@
__ jr(ra);
__ nop();
+ CHECK_EQ(assm.UnboundLabelsCount(), 0);
+
CodeDesc desc;
assm.GetCode(&desc);
Handle<Code> code = isolate->factory()->NewCode(
diff --git a/test/cctest/test-assembler-mips64.cc b/test/cctest/test-assembler-mips64.cc
index dd6ed6b..9529dab 100644
--- a/test/cctest/test-assembler-mips64.cc
+++ b/test/cctest/test-assembler-mips64.cc
@@ -1385,16 +1385,22 @@
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
- typedef struct {
+ struct T {
int64_t r1;
int64_t r2;
int64_t r3;
int64_t r4;
int64_t r5;
int64_t r6;
+ int64_t r7;
+ int64_t r8;
+ int64_t r9;
+ int64_t r10;
+ int64_t r11;
+ int64_t r12;
uint32_t ui;
int32_t si;
- } T;
+ };
T t;
Assembler assm(isolate, NULL, 0);
@@ -1423,26 +1429,25 @@
// lh with positive data.
__ lh(a5, MemOperand(a0, offsetof(T, ui)));
- __ sw(a5, MemOperand(a0, offsetof(T, r2)));
+ __ sw(a5, MemOperand(a0, offsetof(T, r7)));
// lh with negative data.
__ lh(a6, MemOperand(a0, offsetof(T, si)));
- __ sw(a6, MemOperand(a0, offsetof(T, r3)));
+ __ sw(a6, MemOperand(a0, offsetof(T, r8)));
// lhu with negative data.
__ lhu(a7, MemOperand(a0, offsetof(T, si)));
- __ sw(a7, MemOperand(a0, offsetof(T, r4)));
+ __ sw(a7, MemOperand(a0, offsetof(T, r9)));
// lb with negative data.
__ lb(t0, MemOperand(a0, offsetof(T, si)));
- __ sw(t0, MemOperand(a0, offsetof(T, r5)));
+ __ sw(t0, MemOperand(a0, offsetof(T, r10)));
- // // sh writes only 1/2 of word.
- __ lui(t1, 0x3333);
- __ ori(t1, t1, 0x3333);
- __ sw(t1, MemOperand(a0, offsetof(T, r6)));
- __ lhu(t1, MemOperand(a0, offsetof(T, si)));
- __ sh(t1, MemOperand(a0, offsetof(T, r6)));
+ // sh writes only 1/2 of word.
+ __ lw(a4, MemOperand(a0, offsetof(T, ui)));
+ __ sh(a4, MemOperand(a0, offsetof(T, r11)));
+ __ lw(a4, MemOperand(a0, offsetof(T, si)));
+ __ sh(a4, MemOperand(a0, offsetof(T, r12)));
__ jr(ra);
__ nop();
@@ -1454,26 +1459,75 @@
F3 f = FUNCTION_CAST<F3>(code->entry());
t.ui = 0x44332211;
t.si = 0x99aabbcc;
- t.r1 = 0x1111111111111111;
- t.r2 = 0x2222222222222222;
- t.r3 = 0x3333333333333333;
- t.r4 = 0x4444444444444444;
+ t.r1 = 0x5555555555555555;
+ t.r2 = 0x5555555555555555;
+ t.r3 = 0x5555555555555555;
+ t.r4 = 0x5555555555555555;
t.r5 = 0x5555555555555555;
- t.r6 = 0x6666666666666666;
+ t.r6 = 0x5555555555555555;
+ t.r7 = 0x5555555555555555;
+ t.r8 = 0x5555555555555555;
+ t.r9 = 0x5555555555555555;
+ t.r10 = 0x5555555555555555;
+ t.r11 = 0x5555555555555555;
+ t.r12 = 0x5555555555555555;
+
Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
USE(dummy);
- // Unsigned data, 32 & 64.
- CHECK_EQ(static_cast<int64_t>(0x1111111144332211L), t.r1);
- CHECK_EQ(static_cast<int64_t>(0x0000000000002211L), t.r2);
+ if (kArchEndian == kLittle) {
+ // Unsigned data, 32 & 64
+ CHECK_EQ(static_cast<int64_t>(0x5555555544332211L), t.r1); // lw, sw.
+ CHECK_EQ(static_cast<int64_t>(0x0000000044332211L), t.r2); // sd.
- // Signed data, 32 & 64.
- CHECK_EQ(static_cast<int64_t>(0x33333333ffffbbccL), t.r3);
- CHECK_EQ(static_cast<int64_t>(0xffffffff0000bbccL), t.r4);
+ // Signed data, 32 & 64.
+ CHECK_EQ(static_cast<int64_t>(0x5555555599aabbccL), t.r3); // lw, sw.
+ CHECK_EQ(static_cast<int64_t>(0xffffffff99aabbccL), t.r4); // sd.
- // Signed data, 32 & 64.
- CHECK_EQ(static_cast<int64_t>(0x55555555ffffffccL), t.r5);
- CHECK_EQ(static_cast<int64_t>(0x000000003333bbccL), t.r6);
+ // Signed data, 32 & 64.
+ CHECK_EQ(static_cast<int64_t>(0x5555555599aabbccL), t.r5); // lwu, sw.
+ CHECK_EQ(static_cast<int64_t>(0x0000000099aabbccL), t.r6); // sd.
+
+ // lh with unsigned and signed data.
+ CHECK_EQ(static_cast<int64_t>(0x5555555500002211L), t.r7); // lh, sw.
+ CHECK_EQ(static_cast<int64_t>(0x55555555ffffbbccL), t.r8); // lh, sw.
+
+ // lhu with signed data.
+ CHECK_EQ(static_cast<int64_t>(0x555555550000bbccL), t.r9); // lhu, sw.
+
+ // lb with signed data.
+ CHECK_EQ(static_cast<int64_t>(0x55555555ffffffccL), t.r10); // lb, sw.
+
+ // sh with unsigned and signed data.
+ CHECK_EQ(static_cast<int64_t>(0x5555555555552211L), t.r11); // lw, sh.
+ CHECK_EQ(static_cast<int64_t>(0x555555555555bbccL), t.r12); // lw, sh.
+ } else {
+ // Unsigned data, 32 & 64
+ CHECK_EQ(static_cast<int64_t>(0x4433221155555555L), t.r1); // lw, sw.
+ CHECK_EQ(static_cast<int64_t>(0x0000000044332211L), t.r2); // sd.
+
+ // Signed data, 32 & 64.
+ CHECK_EQ(static_cast<int64_t>(0x99aabbcc55555555L), t.r3); // lw, sw.
+ CHECK_EQ(static_cast<int64_t>(0xffffffff99aabbccL), t.r4); // sd.
+
+ // Signed data, 32 & 64.
+ CHECK_EQ(static_cast<int64_t>(0x99aabbcc55555555L), t.r5); // lwu, sw.
+ CHECK_EQ(static_cast<int64_t>(0x0000000099aabbccL), t.r6); // sd.
+
+ // lh with unsigned and signed data.
+ CHECK_EQ(static_cast<int64_t>(0x0000443355555555L), t.r7); // lh, sw.
+ CHECK_EQ(static_cast<int64_t>(0xffff99aa55555555L), t.r8); // lh, sw.
+
+ // lhu with signed data.
+ CHECK_EQ(static_cast<int64_t>(0x000099aa55555555L), t.r9); // lhu, sw.
+
+ // lb with signed data.
+ CHECK_EQ(static_cast<int64_t>(0xffffff9955555555L), t.r10); // lb, sw.
+
+ // sh with unsigned and signed data.
+ CHECK_EQ(static_cast<int64_t>(0x2211555555555555L), t.r11); // lw, sh.
+ CHECK_EQ(static_cast<int64_t>(0xbbcc555555555555L), t.r12); // lw, sh.
+ }
}
@@ -2162,7 +2216,7 @@
__ ldc1(f2, MemOperand(a0, offsetof(TestFloat, a)) );
__ lwc1(f6, MemOperand(a0, offsetof(TestFloat, c)) );
- __ lw(t0, MemOperand(a0, offsetof(TestFloat, rt)) );
+ __ ld(t0, MemOperand(a0, offsetof(TestFloat, rt)));
__ Move(f12, 0.0);
__ Move(f10, 0.0);
__ Move(f16, 0.0);
@@ -3261,6 +3315,8 @@
__ jr(ra);
__ nop();
+ CHECK_EQ(assm.UnboundLabelsCount(), 0);
+
CodeDesc desc;
assm.GetCode(&desc);
Handle<Code> code = isolate->factory()->NewCode(
@@ -5559,15 +5615,22 @@
uint64_t expected_res;
};
- struct TestCaseLdpc tc[] = {
- // offset, expected_res
- { -131072, 0x250ffffe250fffff },
- { -4, 0x250c0006250c0007 },
- { -1, 0x250c0000250c0001 },
- { 0, 0x03001025ef180000 },
- { 1, 0x2508000125080000 },
- { 4, 0x2508000725080006 },
- { 131071, 0x250bfffd250bfffc },
+ auto doubleword = [](uint32_t word2, uint32_t word1) {
+ if (kArchEndian == kLittle)
+ return (static_cast<uint64_t>(word2) << 32) + word1;
+ else
+ return (static_cast<uint64_t>(word1) << 32) + word2;
+ };
+
+ TestCaseLdpc tc[] = {
+ // offset, expected_res
+ {-131072, doubleword(0x250ffffe, 0x250fffff)},
+ {-4, doubleword(0x250c0006, 0x250c0007)},
+ {-1, doubleword(0x250c0000, 0x250c0001)},
+ {0, doubleword(0x03001025, 0xef180000)},
+ {1, doubleword(0x25080001, 0x25080000)},
+ {4, doubleword(0x25080007, 0x25080006)},
+ {131071, doubleword(0x250bfffd, 0x250bfffc)},
};
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseLdpc);
diff --git a/test/cctest/test-assembler-x64.cc b/test/cctest/test-assembler-x64.cc
index 66199fb..e18ae71 100644
--- a/test/cctest/test-assembler-x64.cc
+++ b/test/cctest/test-assembler-x64.cc
@@ -328,6 +328,32 @@
CHECK_EQ(1u, result);
}
+TEST(AssemblerX64TestwOperations) {
+ typedef uint16_t (*F)(uint16_t * x);
+ CcTest::InitializeVM();
+ // Allocate an executable page of memory.
+ size_t actual_size;
+ byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
+ Assembler::kMinimalBufferSize, &actual_size, true));
+ CHECK(buffer);
+ Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));
+
+ // Set rax with the ZF flag of the testl instruction.
+ Label done;
+ __ movq(rax, Immediate(1));
+ __ testw(Operand(arg1, 0), Immediate(0xf0f0));
+ __ j(not_zero, &done, Label::kNear);
+ __ movq(rax, Immediate(0));
+ __ bind(&done);
+ __ ret(0);
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ // Call the function from C++.
+ uint16_t operand = 0x8000;
+ uint16_t result = FUNCTION_CAST<F>(buffer)(&operand);
+ CHECK_EQ(1u, result);
+}
TEST(AssemblerX64XorlOperations) {
CcTest::InitializeVM();
diff --git a/test/cctest/test-ast-expression-visitor.cc b/test/cctest/test-ast-expression-visitor.cc
index bda1fba..5df8253 100644
--- a/test/cctest/test-ast-expression-visitor.cc
+++ b/test/cctest/test-ast-expression-visitor.cc
@@ -3,6 +3,7 @@
// found in the LICENSE file.
#include <stdlib.h>
+#include <map>
#include "src/v8.h"
@@ -19,39 +20,25 @@
namespace {
-static void CollectTypes(HandleAndZoneScope* handles, const char* source,
- ZoneVector<ExpressionTypeEntry>* dst) {
- i::Isolate* isolate = CcTest::i_isolate();
- i::Factory* factory = isolate->factory();
+class NodeTypeCounter : public AstExpressionVisitor {
+ public:
+ typedef std::map<AstNode::NodeType, int> Counters;
- i::Handle<i::String> source_code =
- factory->NewStringFromUtf8(i::CStrVector(source)).ToHandleChecked();
+ NodeTypeCounter(Isolate* isolate, Expression* expr, Counters* counts)
+ : AstExpressionVisitor(isolate, expr), counts_(counts) {}
- i::Handle<i::Script> script = factory->NewScript(source_code);
+ protected:
+ void VisitExpression(Expression* expr) override {
+ (*counts_)[expr->node_type()]++;
+ }
- i::ParseInfo info(handles->main_zone(), script);
- i::Parser parser(&info);
- parser.set_allow_harmony_sloppy(true);
- info.set_global();
- info.set_lazy(false);
- info.set_allow_lazy_parsing(false);
- info.set_toplevel(true);
-
- CHECK(i::Compiler::ParseAndAnalyze(&info));
-
- ExpressionTypeCollector(
- isolate,
- info.scope()->declarations()->at(0)->AsFunctionDeclaration()->fun(), dst)
- .Run();
-}
+ private:
+ Counters* counts_;
+};
} // namespace
-
-TEST(VisitExpressions) {
- v8::V8::Initialize();
- HandleAndZoneScope handles;
- ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
+TEST(VisitExpression) {
const char test_function[] =
"function GeometricMean(stdlib, foreign, buffer) {\n"
" \"use asm\";\n"
@@ -85,339 +72,31 @@
" return { geometricMean: geometricMean };\n"
"}\n";
- CollectTypes(&handles, test_function, &types);
- CHECK_TYPES_BEGIN {
- // function logSum
- CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
- CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(start, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(start, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(end, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(end, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(sum, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(p, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(q, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- // for (p = start << 3, q = end << 3;
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(p, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(start, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(q, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(end, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- }
- // (p|0) < (q|0);
- CHECK_EXPR(CompareOperation, Bounds::Unbounded()) {
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(p, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(q, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- // p = (p + 8)|0) {\n"
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(p, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(p, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- // sum = sum + +log(values[p>>3]);
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(sum, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(sum, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_EXPR(Call, Bounds::Unbounded()) {
- CHECK_VAR(log, Bounds::Unbounded());
- CHECK_EXPR(Property, Bounds::Unbounded()) {
- CHECK_VAR(values, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(p, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- }
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- }
- // return +sum;
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(sum, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- // function geometricMean
- CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(start, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(start, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(end, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(end, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- // return +exp(+logSum(start, end) / +((end - start)|0));
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_EXPR(Call, Bounds::Unbounded()) {
- CHECK_VAR(exp, Bounds::Unbounded());
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_EXPR(Call, Bounds::Unbounded()) {
- CHECK_VAR(logSum, Bounds::Unbounded());
- CHECK_VAR(start, Bounds::Unbounded());
- CHECK_VAR(end, Bounds::Unbounded());
- }
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- CHECK_VAR(end, Bounds::Unbounded());
- CHECK_VAR(start, Bounds::Unbounded());
- }
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- }
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- // "use asm";
- CHECK_EXPR(Literal, Bounds::Unbounded());
- // var exp = stdlib.Math.exp;
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(exp, Bounds::Unbounded());
- CHECK_EXPR(Property, Bounds::Unbounded()) {
- CHECK_EXPR(Property, Bounds::Unbounded()) {
- CHECK_VAR(stdlib, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- // var log = stdlib.Math.log;
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(log, Bounds::Unbounded());
- CHECK_EXPR(Property, Bounds::Unbounded()) {
- CHECK_EXPR(Property, Bounds::Unbounded()) {
- CHECK_VAR(stdlib, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- // var values = new stdlib.Float64Array(buffer);
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(values, Bounds::Unbounded());
- CHECK_EXPR(CallNew, Bounds::Unbounded()) {
- CHECK_EXPR(Property, Bounds::Unbounded()) {
- CHECK_VAR(stdlib, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- CHECK_VAR(buffer, Bounds::Unbounded());
- }
- }
- // return { geometricMean: geometricMean };
- CHECK_EXPR(ObjectLiteral, Bounds::Unbounded()) {
- CHECK_VAR(geometricMean, Bounds::Unbounded());
- }
- }
- }
- CHECK_TYPES_END
-}
-
-
-TEST(VisitConditional) {
+ // Parse + compile test_function, and extract the AST node for it.
v8::V8::Initialize();
HandleAndZoneScope handles;
- ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
- // Check that traversing the ternary operator works.
- const char test_function[] =
- "function foo() {\n"
- " var a, b, c;\n"
- " var x = a ? b : c;\n"
- "}\n";
- CollectTypes(&handles, test_function, &types);
- CHECK_TYPES_BEGIN {
- CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(x, Bounds::Unbounded());
- CHECK_EXPR(Conditional, Bounds::Unbounded()) {
- CHECK_VAR(a, Bounds::Unbounded());
- CHECK_VAR(b, Bounds::Unbounded());
- CHECK_VAR(c, Bounds::Unbounded());
- }
- }
- }
- }
- CHECK_TYPES_END
-}
+ i::Isolate* isolate = CcTest::i_isolate();
+ i::Handle<i::String> source_code =
+ isolate->factory()
+ ->NewStringFromUtf8(i::CStrVector(test_function))
+ .ToHandleChecked();
+ i::Handle<i::Script> script = isolate->factory()->NewScript(source_code);
+ i::ParseInfo info(handles.main_zone(), script);
+ i::Parser parser(&info);
+ info.set_global();
+ info.set_lazy(false);
+ info.set_allow_lazy_parsing(false);
+ info.set_toplevel(true);
+ CHECK(i::Compiler::ParseAndAnalyze(&info));
+ Expression* test_function_expr =
+ info.scope()->declarations()->at(0)->AsFunctionDeclaration()->fun();
-
-TEST(VisitEmptyForStatment) {
- v8::V8::Initialize();
- HandleAndZoneScope handles;
- ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
- // Check that traversing an empty for statement works.
- const char test_function[] =
- "function foo() {\n"
- " for (;;) {}\n"
- "}\n";
- CollectTypes(&handles, test_function, &types);
- CHECK_TYPES_BEGIN {
- CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {}
- }
- CHECK_TYPES_END
-}
-
-
-TEST(VisitSwitchStatment) {
- v8::V8::Initialize();
- HandleAndZoneScope handles;
- ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
- // Check that traversing a switch with a default works.
- const char test_function[] =
- "function foo() {\n"
- " switch (0) { case 1: break; default: break; }\n"
- "}\n";
- CollectTypes(&handles, test_function, &types);
- CHECK_TYPES_BEGIN {
- CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(.switch_tag, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- CHECK_EXPR(Literal, Bounds::Unbounded());
- CHECK_VAR(.switch_tag, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- CHECK_TYPES_END
-}
-
-
-TEST(VisitThrow) {
- v8::V8::Initialize();
- HandleAndZoneScope handles;
- ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
- const char test_function[] =
- "function foo() {\n"
- " throw 123;\n"
- "}\n";
- CollectTypes(&handles, test_function, &types);
- CHECK_TYPES_BEGIN {
- CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
- CHECK_EXPR(Throw, Bounds::Unbounded()) {
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- }
- CHECK_TYPES_END
-}
-
-
-TEST(VisitYield) {
- v8::V8::Initialize();
- HandleAndZoneScope handles;
- ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
- const char test_function[] =
- "function* foo() {\n"
- " yield 123;\n"
- "}\n";
- CollectTypes(&handles, test_function, &types);
- CHECK_TYPES_BEGIN {
- CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
- // Implicit initial yield
- CHECK_EXPR(Yield, Bounds::Unbounded()) {
- CHECK_VAR(.generator_object, Bounds::Unbounded());
- CHECK_EXPR(Assignment, Bounds::Unbounded()) {
- CHECK_VAR(.generator_object, Bounds::Unbounded());
- CHECK_EXPR(CallRuntime, Bounds::Unbounded());
- }
- }
- // Explicit yield (argument wrapped with CreateIterResultObject)
- CHECK_EXPR(Yield, Bounds::Unbounded()) {
- CHECK_VAR(.generator_object, Bounds::Unbounded());
- CHECK_EXPR(CallRuntime, Bounds::Unbounded()) {
- CHECK_EXPR(Literal, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- // Argument to implicit final return
- CHECK_EXPR(CallRuntime, Bounds::Unbounded()) { // CreateIterResultObject
- CHECK_EXPR(Literal, Bounds::Unbounded());
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- // Implicit finally clause
- CHECK_EXPR(CallRuntime, Bounds::Unbounded()) {
- CHECK_VAR(.generator_object, Bounds::Unbounded());
- }
- }
- }
- CHECK_TYPES_END
-}
-
-
-TEST(VisitSkipping) {
- v8::V8::Initialize();
- HandleAndZoneScope handles;
- ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
- const char test_function[] =
- "function foo(x) {\n"
- " return (x + x) + 1;\n"
- "}\n";
- CollectTypes(&handles, test_function, &types);
- CHECK_TYPES_BEGIN {
- CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
- CHECK_EXPR(BinaryOperation, Bounds::Unbounded()) {
- // Skip x + x
- CHECK_SKIP();
- CHECK_EXPR(Literal, Bounds::Unbounded());
- }
- }
- }
- CHECK_TYPES_END
+ // Run NodeTypeCounter and sanity check counts for 3 expression types,
+ // and for overall # of types found.
+ NodeTypeCounter::Counters counts;
+ NodeTypeCounter(isolate, test_function_expr, &counts).Run();
+ CHECK_EQ(21, counts[AstNode::kBinaryOperation]);
+ CHECK_EQ(26, counts[AstNode::kLiteral]);
+ CHECK_EQ(3, counts[AstNode::kFunctionLiteral]);
+ CHECK_EQ(10, counts.size());
}
diff --git a/test/cctest/test-compiler.cc b/test/cctest/test-compiler.cc
index 32d720e..18f0009 100644
--- a/test/cctest/test-compiler.cc
+++ b/test/cctest/test-compiler.cc
@@ -364,9 +364,7 @@
CHECK(!f->shared()->feedback_vector()->is_empty());
}
-
-// Test that optimized code for different closures is actually shared
-// immediately by the FastNewClosureStub when run in the same context.
+// Test that optimized code for different closures is actually shared.
TEST(OptimizedCodeSharing1) {
FLAG_stress_compaction = false;
FLAG_allow_natives_syntax = true;
@@ -385,8 +383,8 @@
"%DebugPrint(closure0());"
"%OptimizeFunctionOnNextCall(closure0);"
"%DebugPrint(closure0());"
- "var closure1 = MakeClosure();"
- "var closure2 = MakeClosure();");
+ "var closure1 = MakeClosure(); closure1();"
+ "var closure2 = MakeClosure(); closure2();");
Handle<JSFunction> fun1 = Handle<JSFunction>::cast(
v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
env->Global()
@@ -403,9 +401,7 @@
}
}
-
-// Test that optimized code for different closures is actually shared
-// immediately by the FastNewClosureStub when run different contexts.
+// Test that optimized code for different closures is actually shared.
TEST(OptimizedCodeSharing2) {
if (FLAG_stress_compaction) return;
FLAG_allow_natives_syntax = true;
@@ -456,8 +452,8 @@
"%DebugPrint(closure0());"
"%OptimizeFunctionOnNextCall(closure0);"
"%DebugPrint(closure0());"
- "var closure1 = MakeClosure();"
- "var closure2 = MakeClosure();");
+ "var closure1 = MakeClosure(); closure1();"
+ "var closure2 = MakeClosure(); closure2();");
Handle<JSFunction> fun1 = Handle<JSFunction>::cast(
v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
env->Global()
@@ -475,9 +471,7 @@
}
}
-
-// Test that optimized code for different closures is actually shared
-// immediately by the FastNewClosureStub without context-dependent entries.
+// Test that optimized code for different closures is actually shared.
TEST(OptimizedCodeSharing3) {
if (FLAG_stress_compaction) return;
FLAG_allow_natives_syntax = true;
@@ -531,8 +525,8 @@
"%DebugPrint(closure0());"
"%OptimizeFunctionOnNextCall(closure0);"
"%DebugPrint(closure0());"
- "var closure1 = MakeClosure();"
- "var closure2 = MakeClosure();");
+ "var closure1 = MakeClosure(); closure1();"
+ "var closure2 = MakeClosure(); closure2();");
Handle<JSFunction> fun1 = Handle<JSFunction>::cast(
v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
env->Global()
diff --git a/test/cctest/test-cpu-profiler.cc b/test/cctest/test-cpu-profiler.cc
index 24c84c3..e4eceec 100644
--- a/test/cctest/test-cpu-profiler.cc
+++ b/test/cctest/test-cpu-profiler.cc
@@ -461,8 +461,7 @@
const v8::CpuProfileNode* result = FindChild(context, node, name);
if (!result) {
char buffer[100];
- i::SNPrintF(Vector<char>(buffer, arraysize(buffer)),
- "Failed to GetChild: %s", name);
+ i::SNPrintF(i::ArrayVector(buffer), "Failed to GetChild: %s", name);
FATAL(buffer);
}
return result;
@@ -1034,8 +1033,8 @@
i::Handle<i::String> str = factory->NewStringFromAsciiChecked(func_name);
int line = 1;
int column = 1;
- profiler.CodeCreateEvent(i::Logger::FUNCTION_TAG, code, func->shared(), NULL,
- *str, line, column);
+ profiler.CodeCreateEvent(i::Logger::FUNCTION_TAG, code, func->shared(), *str,
+ line, column);
// Enqueue a tick event to enable code events processing.
EnqueueTickSampleEvent(processor.get(), code_address);
diff --git a/test/cctest/test-debug.cc b/test/cctest/test-debug.cc
index ab27f39..440c6f1 100644
--- a/test/cctest/test-debug.cc
+++ b/test/cctest/test-debug.cc
@@ -7834,8 +7834,8 @@
CompileRun("var p = new Promise(function(res, rej) { fun(); res(); });");
CompileRun(
"var r;"
- "p.chain(function() { r = 'resolved'; },"
- " function() { r = 'rejected'; });");
+ "p.then(function() { r = 'resolved'; },"
+ " function() { r = 'rejected'; });");
CHECK(CompileRun("r")->Equals(context, v8_str("resolved")).FromJust());
}
@@ -7874,45 +7874,14 @@
CompileRun("var p = new Promise(function(res, rej) { fun(); res(); });");
CompileRun(
"var r;"
- "p.chain(function() { r = 'resolved'; },"
- " function(e) { r = 'rejected' + e; });");
+ "p.then(function() { r = 'resolved'; },"
+ " function(e) { r = 'rejected' + e; });");
CHECK(
CompileRun("r")->Equals(context, v8_str("rejectedrejection")).FromJust());
CHECK_EQ(1, exception_event_counter);
}
-TEST(DebugBreakOnExceptionInObserveCallback) {
- i::FLAG_harmony_object_observe = true;
- DebugLocalContext env;
- v8::Isolate* isolate = env->GetIsolate();
- v8::HandleScope scope(isolate);
- v8::Debug::SetDebugEventListener(isolate, &DebugEventCountException);
- v8::Local<v8::Context> context = env.context();
- // Break on uncaught exception
- ChangeBreakOnException(false, true);
- exception_event_counter = 0;
-
- v8::Local<v8::FunctionTemplate> fun =
- v8::FunctionTemplate::New(isolate, ThrowCallback);
- CHECK(env->Global()
- ->Set(context, v8_str("fun"),
- fun->GetFunction(context).ToLocalChecked())
- .FromJust());
-
- CompileRun(
- "var obj = {};"
- "var callbackRan = false;"
- "Object.observe(obj, function() {"
- " callbackRan = true;"
- " throw Error('foo');"
- "});"
- "obj.prop = 1");
- CHECK(CompileRun("callbackRan")->BooleanValue(context).FromJust());
- CHECK_EQ(1, exception_event_counter);
-}
-
-
static void DebugHarmonyScopingListener(
const v8::Debug::EventDetails& event_details) {
v8::DebugEvent event = event_details.GetEvent();
@@ -8185,3 +8154,36 @@
ExpectString("JSON.stringify(log)",
"[\"a4\",\"b2\",\"c4\",\"e0\",\"e0\",\"e0\",\"e0\",\"f0\"]");
}
+
+size_t current_action = 0;
+StepAction actions[] = {StepNext, StepNext};
+static void DebugStepOverFunctionWithCaughtExceptionListener(
+ const v8::Debug::EventDetails& event_details) {
+ v8::DebugEvent event = event_details.GetEvent();
+ if (event != v8::Break) return;
+ ++break_point_hit_count;
+ if (current_action >= 2) return;
+ PrepareStep(actions[current_action]);
+}
+
+TEST(DebugStepOverFunctionWithCaughtException) {
+ i::FLAG_allow_natives_syntax = true;
+
+ DebugLocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope scope(isolate);
+ v8::Debug::SetDebugEventListener(
+ isolate, DebugStepOverFunctionWithCaughtExceptionListener);
+
+ break_point_hit_count = 0;
+ CompileRun(
+ "function foo() {\n"
+ " try { throw new Error(); } catch (e) {}\n"
+ "}\n"
+ "debugger;\n"
+ "foo();\n"
+ "foo();\n");
+
+ v8::Debug::SetDebugEventListener(env->GetIsolate(), nullptr);
+ CHECK_EQ(break_point_hit_count, 4);
+}
diff --git a/test/cctest/test-disasm-arm.cc b/test/cctest/test-disasm-arm.cc
index 7eea8a1..40745f9 100644
--- a/test/cctest/test-disasm-arm.cc
+++ b/test/cctest/test-disasm-arm.cc
@@ -399,15 +399,6 @@
COMPARE(bfi(r1, r0, 31, 1),
"e7df1f90 bfi r1, r0, #31, #1");
- COMPARE(usat(r0, 1, Operand(r1)),
- "e6e10011 usat r0, #1, r1");
- COMPARE(usat(r2, 7, Operand(lr)),
- "e6e7201e usat r2, #7, lr");
- COMPARE(usat(r3, 31, Operand(r4, LSL, 31)),
- "e6ff3f94 usat r3, #31, r4, lsl #31");
- COMPARE(usat(r8, 0, Operand(r5, ASR, 17)),
- "e6e088d5 usat r8, #0, r5, asr #17");
-
COMPARE(pkhbt(r3, r4, Operand(r5, LSL, 17)),
"e6843895 pkhbt r3, r4, r5, lsl #17");
COMPARE(pkhtb(r3, r4, Operand(r5, ASR, 17)),
@@ -443,6 +434,15 @@
COMPARE(rbit(r10, ip), "e6ffaf3c rbit r10, ip");
}
+ COMPARE(usat(r0, 1, Operand(r1)),
+ "e6e10011 usat r0, #1, r1");
+ COMPARE(usat(r2, 7, Operand(lr)),
+ "e6e7201e usat r2, #7, lr");
+ COMPARE(usat(r3, 31, Operand(r4, LSL, 31)),
+ "e6ff3f94 usat r3, #31, r4, lsl #31");
+ COMPARE(usat(r8, 0, Operand(r5, ASR, 17)),
+ "e6e088d5 usat r8, #0, r5, asr #17");
+
COMPARE(smmla(r0, r1, r2, r3), "e7503211 smmla r0, r1, r2, r3");
COMPARE(smmla(r10, r9, r8, r7), "e75a7819 smmla r10, r9, r8, r7");
@@ -860,6 +860,51 @@
}
+TEST(ARMv8_vselX_disasm) {
+ SET_UP();
+
+ if (CpuFeatures::IsSupported(ARMv8)) {
+ // Native instructions.
+ COMPARE(vsel(eq, d0, d1, d2),
+ "fe010b02 vseleq.f64 d0, d1, d2");
+ COMPARE(vsel(eq, s0, s1, s2),
+ "fe000a81 vseleq.f32 s0, s1, s2");
+ COMPARE(vsel(ge, d0, d1, d2),
+ "fe210b02 vselge.f64 d0, d1, d2");
+ COMPARE(vsel(ge, s0, s1, s2),
+ "fe200a81 vselge.f32 s0, s1, s2");
+ COMPARE(vsel(gt, d0, d1, d2),
+ "fe310b02 vselgt.f64 d0, d1, d2");
+ COMPARE(vsel(gt, s0, s1, s2),
+ "fe300a81 vselgt.f32 s0, s1, s2");
+ COMPARE(vsel(vs, d0, d1, d2),
+ "fe110b02 vselvs.f64 d0, d1, d2");
+ COMPARE(vsel(vs, s0, s1, s2),
+ "fe100a81 vselvs.f32 s0, s1, s2");
+
+ // Inverted conditions (and swapped inputs).
+ COMPARE(vsel(ne, d0, d1, d2),
+ "fe020b01 vseleq.f64 d0, d2, d1");
+ COMPARE(vsel(ne, s0, s1, s2),
+ "fe010a20 vseleq.f32 s0, s2, s1");
+ COMPARE(vsel(lt, d0, d1, d2),
+ "fe220b01 vselge.f64 d0, d2, d1");
+ COMPARE(vsel(lt, s0, s1, s2),
+ "fe210a20 vselge.f32 s0, s2, s1");
+ COMPARE(vsel(le, d0, d1, d2),
+ "fe320b01 vselgt.f64 d0, d2, d1");
+ COMPARE(vsel(le, s0, s1, s2),
+ "fe310a20 vselgt.f32 s0, s2, s1");
+ COMPARE(vsel(vc, d0, d1, d2),
+ "fe120b01 vselvs.f64 d0, d2, d1");
+ COMPARE(vsel(vc, s0, s1, s2),
+ "fe110a20 vselvs.f32 s0, s2, s1");
+ }
+
+ VERIFY_RUN();
+}
+
+
TEST(Neon) {
SET_UP();
diff --git a/test/cctest/test-disasm-ia32.cc b/test/cctest/test-disasm-ia32.cc
index f96eb00..3ecd7b3 100644
--- a/test/cctest/test-disasm-ia32.cc
+++ b/test/cctest/test-disasm-ia32.cc
@@ -29,11 +29,11 @@
#include "src/v8.h"
+#include "src/code-factory.h"
#include "src/debug/debug.h"
#include "src/disasm.h"
#include "src/disassembler.h"
#include "src/ia32/frames-ia32.h"
-#include "src/ic/ic.h"
#include "src/macro-assembler.h"
#include "test/cctest/cctest.h"
@@ -290,7 +290,7 @@
__ bind(&L2);
__ call(Operand(ebx, ecx, times_4, 10000));
__ nop();
- Handle<Code> ic(LoadIC::initialize_stub(isolate, NOT_INSIDE_TYPEOF));
+ Handle<Code> ic(CodeFactory::LoadIC(isolate, NOT_INSIDE_TYPEOF).code());
__ call(ic, RelocInfo::CODE_TARGET);
__ nop();
__ call(FUNCTION_ADDR(DummyStaticFunction), RelocInfo::RUNTIME_ENTRY);
diff --git a/test/cctest/test-disasm-mips64.cc b/test/cctest/test-disasm-mips64.cc
index 8a1e0e7..d8f5681 100644
--- a/test/cctest/test-disasm-mips64.cc
+++ b/test/cctest/test-disasm-mips64.cc
@@ -530,41 +530,28 @@
COMPARE(dsrav(v0, v1, fp),
"03c31017 dsrav v0, v1, fp");
- if (kArchVariant == kMips64r2) {
- COMPARE(rotr(a0, a1, 0),
- "00252002 rotr a0, a1, 0");
- COMPARE(rotr(s0, s1, 8),
- "00318202 rotr s0, s1, 8");
- COMPARE(rotr(a6, a7, 24),
- "002b5602 rotr a6, a7, 24");
- COMPARE(rotr(v0, v1, 31),
- "002317c2 rotr v0, v1, 31");
- COMPARE(drotr(a0, a1, 0),
- "0025203a drotr a0, a1, 0");
- COMPARE(drotr(s0, s1, 8),
- "0031823a drotr s0, s1, 8");
- COMPARE(drotr(a6, a7, 24),
- "002b563a drotr a6, a7, 24");
- COMPARE(drotr(v0, v1, 31),
- "002317fa drotr v0, v1, 31");
+ COMPARE(rotr(a0, a1, 0), "00252002 rotr a0, a1, 0");
+ COMPARE(rotr(s0, s1, 8), "00318202 rotr s0, s1, 8");
+ COMPARE(rotr(a6, a7, 24), "002b5602 rotr a6, a7, 24");
+ COMPARE(rotr(v0, v1, 31), "002317c2 rotr v0, v1, 31");
+ COMPARE(drotr(a0, a1, 0), "0025203a drotr a0, a1, 0");
+ COMPARE(drotr(s0, s1, 8), "0031823a drotr s0, s1, 8");
+ COMPARE(drotr(a6, a7, 24), "002b563a drotr a6, a7, 24");
+ COMPARE(drotr(v0, v1, 31), "002317fa drotr v0, v1, 31");
- COMPARE(rotrv(a0, a1, a2),
- "00c52046 rotrv a0, a1, a2");
- COMPARE(rotrv(s0, s1, s2),
- "02518046 rotrv s0, s1, s2");
- COMPARE(rotrv(a6, a7, t0),
- "018b5046 rotrv a6, a7, t0");
- COMPARE(rotrv(v0, v1, fp),
- "03c31046 rotrv v0, v1, fp");
- COMPARE(drotrv(a0, a1, a2),
- "00c52056 drotrv a0, a1, a2");
- COMPARE(drotrv(s0, s1, s2),
- "02518056 drotrv s0, s1, s2");
- COMPARE(drotrv(a6, a7, t0),
- "018b5056 drotrv a6, a7, t0");
- COMPARE(drotrv(v0, v1, fp),
- "03c31056 drotrv v0, v1, fp");
- }
+ COMPARE(drotr32(a0, a1, 0), "0025203e drotr32 a0, a1, 0");
+ COMPARE(drotr32(s0, s1, 8), "0031823e drotr32 s0, s1, 8");
+ COMPARE(drotr32(a6, a7, 24), "002b563e drotr32 a6, a7, 24");
+ COMPARE(drotr32(v0, v1, 31), "002317fe drotr32 v0, v1, 31");
+
+ COMPARE(rotrv(a0, a1, a2), "00c52046 rotrv a0, a1, a2");
+ COMPARE(rotrv(s0, s1, s2), "02518046 rotrv s0, s1, s2");
+ COMPARE(rotrv(a6, a7, t0), "018b5046 rotrv a6, a7, t0");
+ COMPARE(rotrv(v0, v1, fp), "03c31046 rotrv v0, v1, fp");
+ COMPARE(drotrv(a0, a1, a2), "00c52056 drotrv a0, a1, a2");
+ COMPARE(drotrv(s0, s1, s2), "02518056 drotrv s0, s1, s2");
+ COMPARE(drotrv(a6, a7, t0), "018b5056 drotrv a6, a7, t0");
+ COMPARE(drotrv(v0, v1, fp), "03c31056 drotrv v0, v1, fp");
COMPARE(break_(0),
"0000000d break, code: 0x00000 (0)");
diff --git a/test/cctest/test-disasm-x64.cc b/test/cctest/test-disasm-x64.cc
index 3722c1f..b855626 100644
--- a/test/cctest/test-disasm-x64.cc
+++ b/test/cctest/test-disasm-x64.cc
@@ -29,10 +29,10 @@
#include "src/v8.h"
+#include "src/code-factory.h"
#include "src/debug/debug.h"
#include "src/disasm.h"
#include "src/disassembler.h"
-#include "src/ic/ic.h"
#include "src/macro-assembler.h"
#include "test/cctest/cctest.h"
@@ -282,7 +282,7 @@
// TODO(mstarzinger): The following is protected.
// __ call(Operand(rbx, rcx, times_4, 10000));
__ nop();
- Handle<Code> ic(LoadIC::initialize_stub(isolate, NOT_INSIDE_TYPEOF));
+ Handle<Code> ic(CodeFactory::LoadIC(isolate, NOT_INSIDE_TYPEOF).code());
__ call(ic, RelocInfo::CODE_TARGET);
__ nop();
__ nop();
diff --git a/test/cctest/test-disasm-x87.cc b/test/cctest/test-disasm-x87.cc
index 697a9d3..9a4c6d4 100644
--- a/test/cctest/test-disasm-x87.cc
+++ b/test/cctest/test-disasm-x87.cc
@@ -29,10 +29,10 @@
#include "src/v8.h"
+#include "src/code-factory.h"
#include "src/debug/debug.h"
#include "src/disasm.h"
#include "src/disassembler.h"
-#include "src/ic/ic.h"
#include "src/macro-assembler.h"
#include "src/x87/frames-x87.h"
#include "test/cctest/cctest.h"
@@ -290,7 +290,7 @@
__ bind(&L2);
__ call(Operand(ebx, ecx, times_4, 10000));
__ nop();
- Handle<Code> ic(LoadIC::initialize_stub(isolate, NOT_INSIDE_TYPEOF));
+ Handle<Code> ic(CodeFactory::LoadIC(isolate, NOT_INSIDE_TYPEOF).code());
__ call(ic, RelocInfo::CODE_TARGET);
__ nop();
__ call(FUNCTION_ADDR(DummyStaticFunction), RelocInfo::RUNTIME_ENTRY);
diff --git a/test/cctest/test-field-type-tracking.cc b/test/cctest/test-field-type-tracking.cc
index 7b262db..9709f87 100644
--- a/test/cctest/test-field-type-tracking.cc
+++ b/test/cctest/test-field-type-tracking.cc
@@ -86,6 +86,7 @@
class Expectations {
static const int MAX_PROPERTIES = 10;
Isolate* isolate_;
+ ElementsKind elements_kind_;
PropertyType types_[MAX_PROPERTIES];
PropertyAttributes attributes_[MAX_PROPERTIES];
Representation representations_[MAX_PROPERTIES];
@@ -97,8 +98,15 @@
int number_of_properties_;
public:
+ explicit Expectations(Isolate* isolate, ElementsKind elements_kind)
+ : isolate_(isolate),
+ elements_kind_(elements_kind),
+ number_of_properties_(0) {}
+
explicit Expectations(Isolate* isolate)
- : isolate_(isolate), number_of_properties_(0) {}
+ : Expectations(
+ isolate,
+ isolate->object_function()->initial_map()->elements_kind()) {}
void Init(int index, PropertyType type, PropertyAttributes attributes,
Representation representation, Handle<Object> value) {
@@ -143,6 +151,10 @@
os << "\n";
}
+ void SetElementsKind(ElementsKind elements_kind) {
+ elements_kind_ = elements_kind;
+ }
+
Handle<FieldType> GetFieldType(int index) {
CHECK(index < MAX_PROPERTIES);
CHECK(types_[index] == DATA || types_[index] == ACCESSOR);
@@ -252,6 +264,7 @@
}
bool Check(Map* map, int expected_nof) const {
+ CHECK_EQ(elements_kind_, map->elements_kind());
CHECK(number_of_properties_ <= MAX_PROPERTIES);
CHECK_EQ(expected_nof, map->NumberOfOwnDescriptors());
CHECK(!map->is_dictionary_map());
@@ -279,6 +292,13 @@
// given |map|.
//
+ Handle<Map> AsElementsKind(Handle<Map> map, ElementsKind elements_kind) {
+ elements_kind_ = elements_kind;
+ map = Map::AsElementsKind(map, elements_kind);
+ CHECK_EQ(elements_kind_, map->elements_kind());
+ return map;
+ }
+
Handle<Map> AddDataField(Handle<Map> map, PropertyAttributes attributes,
Representation representation,
Handle<FieldType> heap_type) {
@@ -401,15 +421,8 @@
int descriptor =
map->instance_descriptors()->SearchWithCache(isolate, *name, *map);
- map = Map::TransitionToAccessorProperty(
- map, name, descriptor, ACCESSOR_GETTER, getter, attributes);
- CHECK(!map->is_deprecated());
- CHECK(!map->is_dictionary_map());
-
- descriptor =
- map->instance_descriptors()->SearchWithCache(isolate, *name, *map);
- map = Map::TransitionToAccessorProperty(
- map, name, descriptor, ACCESSOR_SETTER, setter, attributes);
+ map = Map::TransitionToAccessorProperty(isolate, map, name, descriptor,
+ getter, setter, attributes);
CHECK(!map->is_deprecated());
CHECK(!map->is_dictionary_map());
return map;
@@ -589,7 +602,7 @@
// Create new maps by generalizing representation of propX field.
Handle<Map> field_owner(map->FindFieldOwner(property_index), isolate);
- CompilationInfo info("testing", isolate, &zone);
+ CompilationInfo info(ArrayVector("testing"), isolate, &zone);
CHECK(!info.dependencies()->HasAborted());
info.dependencies()->AssumeFieldType(field_owner);
@@ -968,7 +981,7 @@
Zone zone(isolate->allocator());
Handle<Map> field_owner(map->FindFieldOwner(kSplitProp), isolate);
- CompilationInfo info("testing", isolate, &zone);
+ CompilationInfo info(ArrayVector("testing"), isolate, &zone);
CHECK(!info.dependencies()->HasAborted());
info.dependencies()->AssumeFieldType(field_owner);
@@ -1053,7 +1066,7 @@
Zone zone(isolate->allocator());
Handle<Map> field_owner(map->FindFieldOwner(kSplitProp), isolate);
- CompilationInfo info("testing", isolate, &zone);
+ CompilationInfo info(ArrayVector("testing"), isolate, &zone);
CHECK(!info.dependencies()->HasAborted());
info.dependencies()->AssumeFieldType(field_owner);
@@ -1529,6 +1542,271 @@
////////////////////////////////////////////////////////////////////////////////
+// A set of tests for elements kind reconfiguration case.
+//
+
+// This test ensures that representation/field type generalization is correctly
+// propagated from one branch of transition tree (|map2) to another (|map|).
+//
+// + - p0 - p1 - p2A - p3 - p4: |map|
+// |
+// ek
+// |
+// {} - p0 - p1 - p2B - p3 - p4: |map2|
+//
+// where "p2A" and "p2B" differ only in the representation/field type.
+//
+static void TestReconfigureElementsKind_GeneralizeRepresentation(
+ Representation from_representation, Handle<FieldType> from_type,
+ Representation to_representation, Handle<FieldType> to_type,
+ Representation expected_representation, Handle<FieldType> expected_type) {
+ Isolate* isolate = CcTest::i_isolate();
+
+ Expectations expectations(isolate, FAST_SMI_ELEMENTS);
+
+ // Create a map, add required properties to it and initialize expectations.
+ Handle<Map> initial_map = Map::Create(isolate, 0);
+ initial_map->set_elements_kind(FAST_SMI_ELEMENTS);
+
+ Handle<Map> map = initial_map;
+ map = expectations.AsElementsKind(map, FAST_ELEMENTS);
+ for (int i = 0; i < kPropCount; i++) {
+ map = expectations.AddDataField(map, NONE, from_representation, from_type);
+ }
+ CHECK(!map->is_deprecated());
+ CHECK(map->is_stable());
+ CHECK(expectations.Check(*map));
+
+ // Create another branch in transition tree (property at index |kDiffProp|
+ // has different representatio/field type), initialize expectations.
+ const int kDiffProp = kPropCount / 2;
+ Expectations expectations2(isolate, FAST_SMI_ELEMENTS);
+
+ Handle<Map> map2 = initial_map;
+ for (int i = 0; i < kPropCount; i++) {
+ if (i == kDiffProp) {
+ map2 = expectations2.AddDataField(map2, NONE, to_representation, to_type);
+ } else {
+ map2 = expectations2.AddDataField(map2, NONE, from_representation,
+ from_type);
+ }
+ }
+ CHECK(!map2->is_deprecated());
+ CHECK(map2->is_stable());
+ CHECK(expectations2.Check(*map2));
+
+ Zone zone(isolate->allocator());
+ Handle<Map> field_owner(map->FindFieldOwner(kDiffProp), isolate);
+ CompilationInfo info(ArrayVector("testing"), isolate, &zone);
+ CHECK(!info.dependencies()->HasAborted());
+ info.dependencies()->AssumeFieldType(field_owner);
+
+ // Reconfigure elements kinds of |map2|, which should generalize
+ // representations in |map|.
+ Handle<Map> new_map = Map::ReconfigureElementsKind(map2, FAST_ELEMENTS);
+
+ // |map2| should be left unchanged but marked unstable.
+ CHECK(!map2->is_stable());
+ CHECK(!map2->is_deprecated());
+ CHECK_NE(*map2, *new_map);
+ CHECK(expectations2.Check(*map2));
+
+ // |map| should be deprecated and |new_map| should match new expectations.
+ expectations.SetDataField(kDiffProp, expected_representation, expected_type);
+
+ CHECK(map->is_deprecated());
+ CHECK(!info.dependencies()->HasAborted());
+ info.dependencies()->Rollback(); // Properly cleanup compilation info.
+ CHECK_NE(*map, *new_map);
+
+ CHECK(!new_map->is_deprecated());
+ CHECK(expectations.Check(*new_map));
+
+ // Update deprecated |map|, it should become |new_map|.
+ Handle<Map> updated_map = Map::Update(map);
+ CHECK_EQ(*new_map, *updated_map);
+
+ // Ensure Map::FindElementsKindTransitionedMap() is able to find the
+ // transitioned map.
+ {
+ MapHandleList map_list;
+ map_list.Add(updated_map);
+ Map* transitioned_map = map2->FindElementsKindTransitionedMap(&map_list);
+ CHECK_EQ(*updated_map, transitioned_map);
+ }
+}
+
+// This test ensures that trivial representation/field type generalization
+// (from HeapObject to HeapObject) is correctly propagated from one branch of
+// transition tree (|map2|) to another (|map|).
+//
+// + - p0 - p1 - p2A - p3 - p4: |map|
+// |
+// ek
+// |
+// {} - p0 - p1 - p2B - p3 - p4: |map2|
+//
+// where "p2A" and "p2B" differ only in the representation/field type.
+//
+static void TestReconfigureElementsKind_GeneralizeRepresentationTrivial(
+ Representation from_representation, Handle<FieldType> from_type,
+ Representation to_representation, Handle<FieldType> to_type,
+ Representation expected_representation, Handle<FieldType> expected_type,
+ bool expected_field_type_dependency = true) {
+ Isolate* isolate = CcTest::i_isolate();
+
+ Expectations expectations(isolate, FAST_SMI_ELEMENTS);
+
+ // Create a map, add required properties to it and initialize expectations.
+ Handle<Map> initial_map = Map::Create(isolate, 0);
+ initial_map->set_elements_kind(FAST_SMI_ELEMENTS);
+
+ Handle<Map> map = initial_map;
+ map = expectations.AsElementsKind(map, FAST_ELEMENTS);
+ for (int i = 0; i < kPropCount; i++) {
+ map = expectations.AddDataField(map, NONE, from_representation, from_type);
+ }
+ CHECK(!map->is_deprecated());
+ CHECK(map->is_stable());
+ CHECK(expectations.Check(*map));
+
+ // Create another branch in transition tree (property at index |kDiffProp|
+ // has different attributes), initialize expectations.
+ const int kDiffProp = kPropCount / 2;
+ Expectations expectations2(isolate, FAST_SMI_ELEMENTS);
+
+ Handle<Map> map2 = initial_map;
+ for (int i = 0; i < kPropCount; i++) {
+ if (i == kDiffProp) {
+ map2 = expectations2.AddDataField(map2, NONE, to_representation, to_type);
+ } else {
+ map2 = expectations2.AddDataField(map2, NONE, from_representation,
+ from_type);
+ }
+ }
+ CHECK(!map2->is_deprecated());
+ CHECK(map2->is_stable());
+ CHECK(expectations2.Check(*map2));
+
+ Zone zone(isolate->allocator());
+ Handle<Map> field_owner(map->FindFieldOwner(kDiffProp), isolate);
+ CompilationInfo info(ArrayVector("testing"), isolate, &zone);
+ CHECK(!info.dependencies()->HasAborted());
+ info.dependencies()->AssumeFieldType(field_owner);
+
+ // Reconfigure elements kinds of |map2|, which should generalize
+ // representations in |map|.
+ Handle<Map> new_map = Map::ReconfigureElementsKind(map2, FAST_ELEMENTS);
+
+ // |map2| should be left unchanged but marked unstable.
+ CHECK(!map2->is_stable());
+ CHECK(!map2->is_deprecated());
+ CHECK_NE(*map2, *new_map);
+ CHECK(expectations2.Check(*map2));
+
+ // In trivial case |map| should be returned as a result of the elements
+ // kind reconfiguration, respective field types should be generalized and
+ // respective code dependencies should be invalidated. |map| should be NOT
+ // deprecated and it should match new expectations.
+ expectations.SetDataField(kDiffProp, expected_representation, expected_type);
+ CHECK(!map->is_deprecated());
+ CHECK_EQ(*map, *new_map);
+ CHECK_EQ(expected_field_type_dependency, info.dependencies()->HasAborted());
+ info.dependencies()->Rollback(); // Properly cleanup compilation info.
+
+ CHECK(!new_map->is_deprecated());
+ CHECK(expectations.Check(*new_map));
+
+ Handle<Map> updated_map = Map::Update(map);
+ CHECK_EQ(*new_map, *updated_map);
+
+ // Ensure Map::FindElementsKindTransitionedMap() is able to find the
+ // transitioned map.
+ {
+ MapHandleList map_list;
+ map_list.Add(updated_map);
+ Map* transitioned_map = map2->FindElementsKindTransitionedMap(&map_list);
+ CHECK_EQ(*updated_map, transitioned_map);
+ }
+}
+
+TEST(ReconfigureElementsKind_GeneralizeRepresentationSmiToDouble) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Handle<FieldType> any_type = FieldType::Any(isolate);
+
+ TestReconfigureElementsKind_GeneralizeRepresentation(
+ Representation::Smi(), any_type, Representation::Double(), any_type,
+ Representation::Double(), any_type);
+}
+
+TEST(ReconfigureElementsKind_GeneralizeRepresentationSmiToTagged) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Handle<FieldType> any_type = FieldType::Any(isolate);
+ Handle<FieldType> value_type =
+ FieldType::Class(Map::Create(isolate, 0), isolate);
+
+ TestReconfigureElementsKind_GeneralizeRepresentation(
+ Representation::Smi(), any_type, Representation::HeapObject(), value_type,
+ Representation::Tagged(), any_type);
+}
+
+TEST(ReconfigureElementsKind_GeneralizeRepresentationDoubleToTagged) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Handle<FieldType> any_type = FieldType::Any(isolate);
+ Handle<FieldType> value_type =
+ FieldType::Class(Map::Create(isolate, 0), isolate);
+
+ TestReconfigureElementsKind_GeneralizeRepresentation(
+ Representation::Double(), any_type, Representation::HeapObject(),
+ value_type, Representation::Tagged(), any_type);
+}
+
+TEST(ReconfigureElementsKind_GeneralizeRepresentationHeapObjToHeapObj) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Handle<FieldType> any_type = FieldType::Any(isolate);
+
+ Handle<FieldType> current_type =
+ FieldType::Class(Map::Create(isolate, 0), isolate);
+
+ Handle<FieldType> new_type =
+ FieldType::Class(Map::Create(isolate, 0), isolate);
+
+ Handle<FieldType> expected_type = any_type;
+
+ TestReconfigureElementsKind_GeneralizeRepresentationTrivial(
+ Representation::HeapObject(), current_type, Representation::HeapObject(),
+ new_type, Representation::HeapObject(), expected_type);
+ current_type = expected_type;
+
+ new_type = FieldType::Class(Map::Create(isolate, 0), isolate);
+
+ TestReconfigureElementsKind_GeneralizeRepresentationTrivial(
+ Representation::HeapObject(), any_type, Representation::HeapObject(),
+ new_type, Representation::HeapObject(), any_type, false);
+}
+
+TEST(ReconfigureElementsKind_GeneralizeRepresentationHeapObjectToTagged) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Handle<FieldType> any_type = FieldType::Any(isolate);
+ Handle<FieldType> value_type =
+ FieldType::Class(Map::Create(isolate, 0), isolate);
+
+ TestReconfigureElementsKind_GeneralizeRepresentation(
+ Representation::HeapObject(), value_type, Representation::Smi(), any_type,
+ Representation::Tagged(), any_type);
+}
+
+////////////////////////////////////////////////////////////////////////////////
// A set of tests checking split map deprecation.
//
@@ -1644,15 +1922,16 @@
CHECK(map->is_stable());
CHECK(expectations.Check(*map));
+ Expectations expectations2 = expectations;
+
// Apply some special transition to |map|.
CHECK(map->owns_descriptors());
- Handle<Map> map2 = config.Transition(map);
+ Handle<Map> map2 = config.Transition(map, expectations2);
// |map| should still match expectations.
CHECK(!map->is_deprecated());
CHECK(expectations.Check(*map));
- Expectations expectations2 = expectations;
if (config.generalizes_representations()) {
for (int i = 0; i < kPropCount; i++) {
expectations2.GeneralizeRepresentation(i);
@@ -1724,13 +2003,15 @@
FieldType::Class(Map::Create(isolate, 0), isolate);
struct TestConfig {
- Handle<Map> Transition(Handle<Map> map) {
- return Map::CopyAsElementsKind(map, DICTIONARY_ELEMENTS,
- INSERT_TRANSITION);
+ Handle<Map> Transition(Handle<Map> map, Expectations& expectations) {
+ Handle<Symbol> frozen_symbol(map->GetHeap()->frozen_symbol());
+ expectations.SetElementsKind(DICTIONARY_ELEMENTS);
+ return Map::CopyForPreventExtensions(map, NONE, frozen_symbol,
+ "CopyForPreventExtensions");
}
// TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
bool generalizes_representations() const { return false; }
- bool is_non_equevalent_transition() const { return false; }
+ bool is_non_equevalent_transition() const { return true; }
};
TestConfig config;
TestGeneralizeRepresentationWithSpecialTransition(
@@ -1748,7 +2029,7 @@
FieldType::Class(Map::Create(isolate, 0), isolate);
struct TestConfig {
- Handle<Map> Transition(Handle<Map> map) {
+ Handle<Map> Transition(Handle<Map> map, Expectations& expectations) {
Isolate* isolate = CcTest::i_isolate();
Handle<FieldType> any_type = FieldType::Any(isolate);
@@ -1760,65 +2041,10 @@
.ToHandleChecked();
CHECK(!map->owns_descriptors());
- return Map::CopyAsElementsKind(map, DICTIONARY_ELEMENTS,
- INSERT_TRANSITION);
- }
- // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
- bool generalizes_representations() const { return false; }
- bool is_non_equevalent_transition() const { return false; }
- };
- TestConfig config;
- TestGeneralizeRepresentationWithSpecialTransition(
- config, Representation::Smi(), any_type, Representation::HeapObject(),
- value_type, Representation::Tagged(), any_type);
-}
-
-
-TEST(ForObservedTransitionFromMapOwningDescriptor) {
- CcTest::InitializeVM();
- v8::HandleScope scope(CcTest::isolate());
- Isolate* isolate = CcTest::i_isolate();
- Handle<FieldType> any_type = FieldType::Any(isolate);
- Handle<FieldType> value_type =
- FieldType::Class(Map::Create(isolate, 0), isolate);
-
- struct TestConfig {
- Handle<Map> Transition(Handle<Map> map) {
- return Map::CopyForObserved(map);
- }
- // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
- bool generalizes_representations() const { return false; }
- bool is_non_equevalent_transition() const { return true; }
- };
- TestConfig config;
- TestGeneralizeRepresentationWithSpecialTransition(
- config, Representation::Smi(), any_type, Representation::HeapObject(),
- value_type, Representation::Tagged(), any_type);
-}
-
-
-TEST(ForObservedTransitionFromMapNotOwningDescriptor) {
- CcTest::InitializeVM();
- v8::HandleScope scope(CcTest::isolate());
- Isolate* isolate = CcTest::i_isolate();
- Handle<FieldType> any_type = FieldType::Any(isolate);
- Handle<FieldType> value_type =
- FieldType::Class(Map::Create(isolate, 0), isolate);
-
- struct TestConfig {
- Handle<Map> Transition(Handle<Map> map) {
- Isolate* isolate = CcTest::i_isolate();
- Handle<FieldType> any_type = FieldType::Any(isolate);
-
- // Add one more transition to |map| in order to prevent descriptors
- // ownership.
- CHECK(map->owns_descriptors());
- Map::CopyWithField(map, MakeString("foo"), any_type, NONE,
- Representation::Smi(), INSERT_TRANSITION)
- .ToHandleChecked();
- CHECK(!map->owns_descriptors());
-
- return Map::CopyForObserved(map);
+ Handle<Symbol> frozen_symbol(map->GetHeap()->frozen_symbol());
+ expectations.SetElementsKind(DICTIONARY_ELEMENTS);
+ return Map::CopyForPreventExtensions(map, NONE, frozen_symbol,
+ "CopyForPreventExtensions");
}
// TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
bool generalizes_representations() const { return false; }
@@ -1849,7 +2075,7 @@
prototype_ = factory->NewJSObjectFromMap(Map::Create(isolate, 0));
}
- Handle<Map> Transition(Handle<Map> map) {
+ Handle<Map> Transition(Handle<Map> map, Expectations& expectations) {
return Map::TransitionToPrototype(map, prototype_, REGULAR_PROTOTYPE);
}
// TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
@@ -1883,7 +2109,7 @@
prototype_ = factory->NewJSObjectFromMap(Map::Create(isolate, 0));
}
- Handle<Map> Transition(Handle<Map> map) {
+ Handle<Map> Transition(Handle<Map> map, Expectations& expectations) {
Isolate* isolate = CcTest::i_isolate();
Handle<FieldType> any_type = FieldType::Any(isolate);
diff --git a/test/cctest/test-global-handles.cc b/test/cctest/test-global-handles.cc
index 22fd785..06e7466 100644
--- a/test/cctest/test-global-handles.cc
+++ b/test/cctest/test-global-handles.cc
@@ -417,3 +417,55 @@
// Should not crash.
g.SetWeak<void>(nullptr, &WeakCallback, v8::WeakCallbackType::kParameter);
}
+
+void finalizer(const v8::WeakCallbackInfo<v8::Global<v8::Object>>& data) {
+ data.GetParameter()->ClearWeak();
+ v8::Local<v8::Object> o =
+ v8::Local<v8::Object>::New(data.GetIsolate(), *data.GetParameter());
+ o->Set(data.GetIsolate()->GetCurrentContext(), v8_str("finalizer"),
+ v8_str("was here"))
+ .FromJust();
+}
+
+TEST(FinalizerWeakness) {
+ CcTest::InitializeVM();
+ v8::Isolate* isolate = CcTest::isolate();
+
+ v8::Global<v8::Object> g;
+ int identity;
+
+ {
+ v8::HandleScope scope(isolate);
+ v8::Local<v8::Object> o = v8::Object::New(isolate);
+ identity = o->GetIdentityHash();
+ g.Reset(isolate, o);
+ g.SetWeak(&g, finalizer, v8::WeakCallbackType::kFinalizer);
+ }
+
+ CcTest::i_isolate()->heap()->CollectAllAvailableGarbage();
+
+ CHECK(!g.IsEmpty());
+ v8::HandleScope scope(isolate);
+ v8::Local<v8::Object> o = v8::Local<v8::Object>::New(isolate, g);
+ CHECK_EQ(identity, o->GetIdentityHash());
+ CHECK(o->Has(isolate->GetCurrentContext(), v8_str("finalizer")).FromJust());
+}
+
+TEST(PhatomHandlesWithoutCallbacks) {
+ CcTest::InitializeVM();
+ v8::Isolate* isolate = CcTest::isolate();
+
+ v8::Global<v8::Object> g1, g2;
+ {
+ v8::HandleScope scope(isolate);
+ g1.Reset(isolate, v8::Object::New(isolate));
+ g1.SetWeak();
+ g2.Reset(isolate, v8::Object::New(isolate));
+ g2.SetWeak();
+ }
+
+ CHECK_EQ(0, isolate->NumberOfPhantomHandleResetsSinceLastCall());
+ CcTest::i_isolate()->heap()->CollectAllAvailableGarbage();
+ CHECK_EQ(2, isolate->NumberOfPhantomHandleResetsSinceLastCall());
+ CHECK_EQ(0, isolate->NumberOfPhantomHandleResetsSinceLastCall());
+}
diff --git a/test/cctest/test-heap-profiler.cc b/test/cctest/test-heap-profiler.cc
index dfe5911..767c5cd 100644
--- a/test/cctest/test-heap-profiler.cc
+++ b/test/cctest/test-heap-profiler.cc
@@ -44,6 +44,7 @@
using i::AllocationTraceTree;
using i::AllocationTracker;
using i::HashMap;
+using i::ArrayVector;
using i::Vector;
namespace {
@@ -2513,8 +2514,7 @@
// Print for better diagnostics in case of failure.
tracker->trace_tree()->Print(tracker);
- AllocationTraceNode* node =
- FindNode(tracker, Vector<const char*>(names, arraysize(names)));
+ AllocationTraceNode* node = FindNode(tracker, ArrayVector(names));
CHECK(node);
CHECK_GE(node->allocation_count(), 2u);
CHECK_GE(node->allocation_size(), 4u * 5u);
@@ -2540,8 +2540,7 @@
tracker->trace_tree()->Print(tracker);
const char* names[] = {"", "start", "f_0_0", "f_0_1", "f_0_2"};
- AllocationTraceNode* node =
- FindNode(tracker, Vector<const char*>(names, arraysize(names)));
+ AllocationTraceNode* node = FindNode(tracker, ArrayVector(names));
CHECK(node);
CHECK_GE(node->allocation_count(), 100u);
CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
@@ -2590,8 +2589,7 @@
// Print for better diagnostics in case of failure.
tracker->trace_tree()->Print(tracker);
- AllocationTraceNode* node =
- FindNode(tracker, Vector<const char*>(names, arraysize(names)));
+ AllocationTraceNode* node = FindNode(tracker, ArrayVector(names));
CHECK(node);
CHECK_GE(node->allocation_count(), 100u);
CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
@@ -2616,8 +2614,7 @@
// Print for better diagnostics in case of failure.
tracker->trace_tree()->Print(tracker);
- AllocationTraceNode* node =
- FindNode(tracker, Vector<const char*>(names, arraysize(names)));
+ AllocationTraceNode* node = FindNode(tracker, ArrayVector(names));
CHECK(node);
CHECK_LT(node->allocation_count(), 100u);
@@ -2646,8 +2643,7 @@
// Print for better diagnostics in case of failure.
tracker->trace_tree()->Print(tracker);
- AllocationTraceNode* node =
- FindNode(tracker, Vector<const char*>(names, arraysize(names)));
+ AllocationTraceNode* node = FindNode(tracker, ArrayVector(names));
CHECK(node);
CHECK_GE(node->allocation_count(), 2u);
CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
@@ -2875,6 +2871,15 @@
return node;
}
+static void CheckNoZeroCountNodes(v8::AllocationProfile::Node* node) {
+ for (auto alloc : node->allocations) {
+ CHECK_GT(alloc.count, 0u);
+ }
+ for (auto child : node->children) {
+ CheckNoZeroCountNodes(child);
+ }
+}
+
TEST(SamplingHeapProfiler) {
v8::HandleScope scope(v8::Isolate::GetCurrent());
LocalContext env;
@@ -2913,8 +2918,7 @@
CHECK(!profile.is_empty());
const char* names[] = {"", "foo", "bar"};
- auto node_bar = FindAllocationProfileNode(
- *profile, Vector<const char*>(names, arraysize(names)));
+ auto node_bar = FindAllocationProfileNode(*profile, ArrayVector(names));
CHECK(node_bar);
// Count the number of allocations we sampled from bar.
@@ -2941,8 +2945,7 @@
CHECK(!profile.is_empty());
const char* names[] = {"", "foo", "bar"};
- auto node_bar = FindAllocationProfileNode(
- *profile, Vector<const char*>(names, arraysize(names)));
+ auto node_bar = FindAllocationProfileNode(*profile, ArrayVector(names));
CHECK(node_bar);
// Count the number of allocations we sampled from bar.
@@ -2976,13 +2979,11 @@
CHECK(!profile.is_empty());
const char* names1[] = {"", "start", "f_0_0", "f_0_1", "f_0_2"};
- auto node1 = FindAllocationProfileNode(
- *profile, Vector<const char*>(names1, arraysize(names1)));
+ auto node1 = FindAllocationProfileNode(*profile, ArrayVector(names1));
CHECK(node1);
const char* names2[] = {"", "generateFunctions"};
- auto node2 = FindAllocationProfileNode(
- *profile, Vector<const char*>(names2, arraysize(names2)));
+ auto node2 = FindAllocationProfileNode(*profile, ArrayVector(names2));
CHECK(node2);
heap_profiler->StopSamplingHeapProfiler();
@@ -3002,6 +3003,8 @@
heap_profiler->GetAllocationProfile());
CHECK(!profile.is_empty());
+ CheckNoZeroCountNodes(profile->GetRootNode());
+
heap_profiler->StopSamplingHeapProfiler();
}
}
@@ -3023,8 +3026,7 @@
heap_profiler->GetAllocationProfile());
CHECK(!profile.is_empty());
const char* names[] = {"(V8 API)"};
- auto node = FindAllocationProfileNode(
- *profile, Vector<const char*>(names, arraysize(names)));
+ auto node = FindAllocationProfileNode(*profile, ArrayVector(names));
CHECK(node);
heap_profiler->StopSamplingHeapProfiler();
diff --git a/test/cctest/test-log-stack-tracer.cc b/test/cctest/test-log-stack-tracer.cc
index 05d7103..e38d74e 100644
--- a/test/cctest/test-log-stack-tracer.cc
+++ b/test/cctest/test-log-stack-tracer.cc
@@ -36,7 +36,7 @@
#include "src/disassembler.h"
#include "src/isolate.h"
#include "src/log.h"
-#include "src/profiler/sampler.h"
+#include "src/profiler/tick-sample.h"
#include "src/vm-state-inl.h"
#include "test/cctest/cctest.h"
#include "test/cctest/trace-extension.h"
diff --git a/test/cctest/test-log.cc b/test/cctest/test-log.cc
index 9c7e63b..c3856f2 100644
--- a/test/cctest/test-log.cc
+++ b/test/cctest/test-log.cc
@@ -375,9 +375,8 @@
ObjMethod1_entry = *FUNCTION_ENTRYPOINT_ADDRESS(ObjMethod1_entry);
#endif
i::EmbeddedVector<char, 100> ref_data;
- i::SNPrintF(ref_data,
- "code-creation,Callback,-2,0x%" V8PRIxPTR ",1,\"method1\"",
- reinterpret_cast<intptr_t>(ObjMethod1_entry));
+ i::SNPrintF(ref_data, "code-creation,Callback,-2,%p,1,\"method1\"",
+ ObjMethod1_entry);
CHECK(StrNStr(log.start(), ref_data.start(), log.length()));
log.Dispose();
@@ -429,8 +428,8 @@
#endif
EmbeddedVector<char, 100> prop1_getter_record;
i::SNPrintF(prop1_getter_record,
- "code-creation,Callback,-2,0x%" V8PRIxPTR ",1,\"get prop1\"",
- reinterpret_cast<intptr_t>(Prop1Getter_entry));
+ "code-creation,Callback,-2,%p,1,\"get prop1\"",
+ Prop1Getter_entry);
CHECK(StrNStr(log.start(), prop1_getter_record.start(), log.length()));
Address Prop1Setter_entry = reinterpret_cast<Address>(Prop1Setter);
@@ -439,8 +438,8 @@
#endif
EmbeddedVector<char, 100> prop1_setter_record;
i::SNPrintF(prop1_setter_record,
- "code-creation,Callback,-2,0x%" V8PRIxPTR ",1,\"set prop1\"",
- reinterpret_cast<intptr_t>(Prop1Setter_entry));
+ "code-creation,Callback,-2,%p,1,\"set prop1\"",
+ Prop1Setter_entry);
CHECK(StrNStr(log.start(), prop1_setter_record.start(), log.length()));
Address Prop2Getter_entry = reinterpret_cast<Address>(Prop2Getter);
@@ -449,8 +448,8 @@
#endif
EmbeddedVector<char, 100> prop2_getter_record;
i::SNPrintF(prop2_getter_record,
- "code-creation,Callback,-2,0x%" V8PRIxPTR ",1,\"get prop2\"",
- reinterpret_cast<intptr_t>(Prop2Getter_entry));
+ "code-creation,Callback,-2,%p,1,\"get prop2\"",
+ Prop2Getter_entry);
CHECK(StrNStr(log.start(), prop2_getter_record.start(), log.length()));
log.Dispose();
}
diff --git a/test/cctest/test-macro-assembler-mips.cc b/test/cctest/test-macro-assembler-mips.cc
index 91ee215..5408061 100644
--- a/test/cctest/test-macro-assembler-mips.cc
+++ b/test/cctest/test-macro-assembler-mips.cc
@@ -390,14 +390,14 @@
}
}
-static const std::vector<uint32_t> uint32_test_values() {
+static const std::vector<uint32_t> cvt_trunc_uint32_test_values() {
static const uint32_t kValues[] = {0x00000000, 0x00000001, 0x00ffff00,
0x7fffffff, 0x80000000, 0x80000001,
0x80ffff00, 0x8fffffff, 0xffffffff};
return std::vector<uint32_t>(&kValues[0], &kValues[arraysize(kValues)]);
}
-static const std::vector<int32_t> int32_test_values() {
+static const std::vector<int32_t> cvt_trunc_int32_test_values() {
static const int32_t kValues[] = {
static_cast<int32_t>(0x00000000), static_cast<int32_t>(0x00000001),
static_cast<int32_t>(0x00ffff00), static_cast<int32_t>(0x7fffffff),
@@ -408,13 +408,31 @@
}
// Helper macros that can be used in FOR_INT32_INPUTS(i) { ... *i ... }
-#define FOR_INPUTS(ctype, itype, var) \
- std::vector<ctype> var##_vec = itype##_test_values(); \
+#define FOR_INPUTS(ctype, itype, var, test_vector) \
+ std::vector<ctype> var##_vec = test_vector(); \
for (std::vector<ctype>::iterator var = var##_vec.begin(); \
var != var##_vec.end(); ++var)
-#define FOR_UINT32_INPUTS(var) FOR_INPUTS(uint32_t, uint32, var)
-#define FOR_INT32_INPUTS(var) FOR_INPUTS(int32_t, int32, var)
+#define FOR_INPUTS2(ctype, itype, var, var2, test_vector) \
+ std::vector<ctype> var##_vec = test_vector(); \
+ std::vector<ctype>::iterator var; \
+ std::vector<ctype>::reverse_iterator var2; \
+ for (var = var##_vec.begin(), var2 = var##_vec.rbegin(); \
+ var != var##_vec.end(); ++var, ++var2)
+
+#define FOR_ENUM_INPUTS(var, type, test_vector) \
+ FOR_INPUTS(enum type, type, var, test_vector)
+#define FOR_STRUCT_INPUTS(var, type, test_vector) \
+ FOR_INPUTS(struct type, type, var, test_vector)
+#define FOR_UINT32_INPUTS(var, test_vector) \
+ FOR_INPUTS(uint32_t, uint32, var, test_vector)
+#define FOR_INT32_INPUTS(var, test_vector) \
+ FOR_INPUTS(int32_t, int32, var, test_vector)
+#define FOR_INT32_INPUTS2(var, var2, test_vector) \
+ FOR_INPUTS2(int32_t, int32, var, var2, test_vector)
+
+#define FOR_UINT64_INPUTS(var, test_vector) \
+ FOR_INPUTS(uint64_t, uint32, var, test_vector)
template <typename RET_TYPE, typename IN_TYPE, typename Func>
RET_TYPE run_Cvt(IN_TYPE x, Func GenerateConvertInstructionFunc) {
@@ -445,7 +463,7 @@
TEST(cvt_s_w_Trunc_uw_s) {
CcTest::InitializeVM();
- FOR_UINT32_INPUTS(i) {
+ FOR_UINT32_INPUTS(i, cvt_trunc_uint32_test_values) {
uint32_t input = *i;
CHECK_EQ(static_cast<float>(input),
run_Cvt<uint32_t>(input, [](MacroAssembler* masm) {
@@ -457,7 +475,7 @@
TEST(cvt_d_w_Trunc_w_d) {
CcTest::InitializeVM();
- FOR_INT32_INPUTS(i) {
+ FOR_INT32_INPUTS(i, cvt_trunc_int32_test_values) {
int32_t input = *i;
CHECK_EQ(static_cast<double>(input),
run_Cvt<int32_t>(input, [](MacroAssembler* masm) {
@@ -467,6 +485,342 @@
}
}
+static const std::vector<int32_t> overflow_int32_test_values() {
+ static const int32_t kValues[] = {
+ static_cast<int32_t>(0xf0000000), static_cast<int32_t>(0x00000001),
+ static_cast<int32_t>(0xff000000), static_cast<int32_t>(0x0000f000),
+ static_cast<int32_t>(0x0f000000), static_cast<int32_t>(0x991234ab),
+ static_cast<int32_t>(0xb0ffff01), static_cast<int32_t>(0x00006fff),
+ static_cast<int32_t>(0xffffffff)};
+ return std::vector<int32_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+enum OverflowBranchType {
+ kAddBranchOverflow,
+ kSubBranchOverflow,
+};
+
+struct OverflowRegisterCombination {
+ Register dst;
+ Register left;
+ Register right;
+ Register scratch;
+};
+
+static const std::vector<enum OverflowBranchType> overflow_branch_type() {
+ static const enum OverflowBranchType kValues[] = {kAddBranchOverflow,
+ kSubBranchOverflow};
+ return std::vector<enum OverflowBranchType>(&kValues[0],
+ &kValues[arraysize(kValues)]);
+}
+
+static const std::vector<struct OverflowRegisterCombination>
+overflow_register_combination() {
+ static const struct OverflowRegisterCombination kValues[] = {
+ {t0, t1, t2, t3}, {t0, t0, t2, t3}, {t0, t1, t0, t3}, {t0, t1, t1, t3}};
+ return std::vector<struct OverflowRegisterCombination>(
+ &kValues[0], &kValues[arraysize(kValues)]);
+}
+
+template <typename T>
+static bool IsAddOverflow(T x, T y) {
+ DCHECK(std::numeric_limits<T>::is_integer);
+ T max = std::numeric_limits<T>::max();
+ T min = std::numeric_limits<T>::min();
+
+ return (x > 0 && y > (max - x)) || (x < 0 && y < (min - x));
+}
+
+template <typename T>
+static bool IsSubOverflow(T x, T y) {
+ DCHECK(std::numeric_limits<T>::is_integer);
+ T max = std::numeric_limits<T>::max();
+ T min = std::numeric_limits<T>::min();
+
+ return (y > 0 && x < (min + y)) || (y < 0 && x > (max + y));
+}
+
+template <typename IN_TYPE, typename Func>
+static bool runOverflow(IN_TYPE valLeft, IN_TYPE valRight,
+ Func GenerateOverflowInstructions) {
+ typedef int32_t (*F_CVT)(char* x0, int x1, int x2, int x3, int x4);
+
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+ MacroAssembler assm(isolate, nullptr, 0,
+ v8::internal::CodeObjectRequired::kYes);
+ MacroAssembler* masm = &assm;
+
+ GenerateOverflowInstructions(masm, valLeft, valRight);
+ __ jr(ra);
+ __ nop();
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+ F_CVT f = FUNCTION_CAST<F_CVT>(code->entry());
+
+ int32_t r =
+ reinterpret_cast<int32_t>(CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
+
+ DCHECK(r == 0 || r == 1);
+ return r;
+}
+
+TEST(BranchOverflowInt32BothLabels) {
+ FOR_INT32_INPUTS(i, overflow_int32_test_values) {
+ FOR_INT32_INPUTS(j, overflow_int32_test_values) {
+ FOR_ENUM_INPUTS(br, OverflowBranchType, overflow_branch_type) {
+ FOR_STRUCT_INPUTS(regComb, OverflowRegisterCombination,
+ overflow_register_combination) {
+ int32_t ii = *i;
+ int32_t jj = *j;
+ enum OverflowBranchType branchType = *br;
+ struct OverflowRegisterCombination rc = *regComb;
+
+ // If left and right register are same then left and right
+ // test values must also be same, otherwise we skip the test
+ if (rc.left.code() == rc.right.code()) {
+ if (ii != jj) {
+ continue;
+ }
+ }
+
+ bool res1 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label overflow, no_overflow, end;
+ __ li(rc.left, valLeft);
+ __ li(rc.right, valRight);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, rc.right, &overflow,
+ &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, rc.right, &overflow,
+ &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 2);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ bool res2 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label overflow, no_overflow, end;
+ __ li(rc.left, valLeft);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 2);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ switch (branchType) {
+ case kAddBranchOverflow:
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res2);
+ break;
+ case kSubBranchOverflow:
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res2);
+ break;
+ default:
+ UNREACHABLE();
+ }
+ }
+ }
+ }
+ }
+}
+
+TEST(BranchOverflowInt32LeftLabel) {
+ FOR_INT32_INPUTS(i, overflow_int32_test_values) {
+ FOR_INT32_INPUTS(j, overflow_int32_test_values) {
+ FOR_ENUM_INPUTS(br, OverflowBranchType, overflow_branch_type) {
+ FOR_STRUCT_INPUTS(regComb, OverflowRegisterCombination,
+ overflow_register_combination) {
+ int32_t ii = *i;
+ int32_t jj = *j;
+ enum OverflowBranchType branchType = *br;
+ struct OverflowRegisterCombination rc = *regComb;
+
+ // If left and right register are same then left and right
+ // test values must also be same, otherwise we skip the test
+ if (rc.left.code() == rc.right.code()) {
+ if (ii != jj) {
+ continue;
+ }
+ }
+
+ bool res1 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label overflow, end;
+ __ li(rc.left, valLeft);
+ __ li(rc.right, valRight);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, rc.right, &overflow, NULL,
+ rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, rc.right, &overflow, NULL,
+ rc.scratch);
+ break;
+ }
+ __ li(v0, 0);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ bind(&end);
+ });
+
+ bool res2 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label overflow, end;
+ __ li(rc.left, valLeft);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, NULL, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, NULL, rc.scratch);
+ break;
+ }
+ __ li(v0, 0);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ bind(&end);
+ });
+
+ switch (branchType) {
+ case kAddBranchOverflow:
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res2);
+ break;
+ case kSubBranchOverflow:
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res2);
+ break;
+ default:
+ UNREACHABLE();
+ }
+ }
+ }
+ }
+ }
+}
+
+TEST(BranchOverflowInt32RightLabel) {
+ FOR_INT32_INPUTS(i, overflow_int32_test_values) {
+ FOR_INT32_INPUTS(j, overflow_int32_test_values) {
+ FOR_ENUM_INPUTS(br, OverflowBranchType, overflow_branch_type) {
+ FOR_STRUCT_INPUTS(regComb, OverflowRegisterCombination,
+ overflow_register_combination) {
+ int32_t ii = *i;
+ int32_t jj = *j;
+ enum OverflowBranchType branchType = *br;
+ struct OverflowRegisterCombination rc = *regComb;
+
+ // If left and right register are same then left and right
+ // test values must also be same, otherwise we skip the test
+ if (rc.left.code() == rc.right.code()) {
+ if (ii != jj) {
+ continue;
+ }
+ }
+
+ bool res1 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label no_overflow, end;
+ __ li(rc.left, valLeft);
+ __ li(rc.right, valRight);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, rc.right, NULL,
+ &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, rc.right, NULL,
+ &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ bool res2 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label no_overflow, end;
+ __ li(rc.left, valLeft);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, Operand(valRight), NULL,
+ &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, Operand(valRight), NULL,
+ &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ switch (branchType) {
+ case kAddBranchOverflow:
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res2);
+ break;
+ case kSubBranchOverflow:
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res2);
+ break;
+ default:
+ UNREACHABLE();
+ }
+ }
+ }
+ }
+ }
+}
+
TEST(min_max_nan) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
@@ -577,4 +931,241 @@
}
}
+template <typename IN_TYPE, typename Func>
+bool run_Unaligned(char* memory_buffer, int32_t in_offset, int32_t out_offset,
+ IN_TYPE value, Func GenerateUnalignedInstructionFunc) {
+ typedef int32_t (*F_CVT)(char* x0, int x1, int x2, int x3, int x4);
+
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+ MacroAssembler assm(isolate, nullptr, 0,
+ v8::internal::CodeObjectRequired::kYes);
+ MacroAssembler* masm = &assm;
+ IN_TYPE res;
+
+ GenerateUnalignedInstructionFunc(masm, in_offset, out_offset);
+ __ jr(ra);
+ __ nop();
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+ F_CVT f = FUNCTION_CAST<F_CVT>(code->entry());
+
+ MemCopy(memory_buffer + in_offset, &value, sizeof(IN_TYPE));
+ CALL_GENERATED_CODE(isolate, f, memory_buffer, 0, 0, 0, 0);
+ MemCopy(&res, memory_buffer + out_offset, sizeof(IN_TYPE));
+
+ return res == value;
+}
+
+static const std::vector<uint64_t> unsigned_test_values() {
+ static const uint64_t kValues[] = {
+ 0x2180f18a06384414, 0x000a714532102277, 0xbc1acccf180649f0,
+ 0x8000000080008000, 0x0000000000000001, 0xffffffffffffffff,
+ };
+ return std::vector<uint64_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+static const std::vector<int32_t> unsigned_test_offset() {
+ static const int32_t kValues[] = {// value, offset
+ -132 * KB, -21 * KB, 0, 19 * KB, 135 * KB};
+ return std::vector<int32_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+static const std::vector<int32_t> unsigned_test_offset_increment() {
+ static const int32_t kValues[] = {-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5};
+ return std::vector<int32_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+TEST(Ulh) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ uint16_t value = static_cast<uint64_t>(*i & 0xFFFF);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<uint16_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Ulh(v0, MemOperand(a0, in_offset));
+ __ Ush(v0, MemOperand(a0, out_offset), v0);
+ }));
+ CHECK_EQ(true, run_Unaligned<uint16_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ mov(t0, a0);
+ __ Ulh(a0, MemOperand(a0, in_offset));
+ __ Ush(a0, MemOperand(t0, out_offset), v0);
+ }));
+ CHECK_EQ(true, run_Unaligned<uint16_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ mov(t0, a0);
+ __ Ulhu(a0, MemOperand(a0, in_offset));
+ __ Ush(a0, MemOperand(t0, out_offset), t1);
+ }));
+ CHECK_EQ(true, run_Unaligned<uint16_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Ulhu(v0, MemOperand(a0, in_offset));
+ __ Ush(v0, MemOperand(a0, out_offset), t1);
+ }));
+ }
+ }
+ }
+}
+
+TEST(Ulh_bitextension) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ uint16_t value = static_cast<uint64_t>(*i & 0xFFFF);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<uint16_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ Label success, fail, end, different;
+ __ Ulh(t0, MemOperand(a0, in_offset));
+ __ Ulhu(t1, MemOperand(a0, in_offset));
+ __ Branch(&different, ne, t0, Operand(t1));
+
+ // If signed and unsigned values are same, check
+ // the upper bits to see if they are zero
+ __ sra(t0, t0, 15);
+ __ Branch(&success, eq, t0, Operand(zero_reg));
+ __ Branch(&fail);
+
+ // If signed and unsigned values are different,
+ // check that the upper bits are complementary
+ __ bind(&different);
+ __ sra(t1, t1, 15);
+ __ Branch(&fail, ne, t1, Operand(1));
+ __ sra(t0, t0, 15);
+ __ addiu(t0, t0, 1);
+ __ Branch(&fail, ne, t0, Operand(zero_reg));
+ // Fall through to success
+
+ __ bind(&success);
+ __ Ulh(t0, MemOperand(a0, in_offset));
+ __ Ush(t0, MemOperand(a0, out_offset), v0);
+ __ Branch(&end);
+ __ bind(&fail);
+ __ Ush(zero_reg, MemOperand(a0, out_offset), v0);
+ __ bind(&end);
+ }));
+ }
+ }
+ }
+}
+
+TEST(Ulw) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ uint32_t value = static_cast<uint32_t>(*i & 0xFFFFFFFF);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<uint32_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Ulw(v0, MemOperand(a0, in_offset));
+ __ Usw(v0, MemOperand(a0, out_offset));
+ }));
+ CHECK_EQ(true,
+ run_Unaligned<uint32_t>(
+ buffer_middle, in_offset, out_offset, (uint32_t)value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ mov(t0, a0);
+ __ Ulw(a0, MemOperand(a0, in_offset));
+ __ Usw(a0, MemOperand(t0, out_offset));
+ }));
+ }
+ }
+ }
+}
+
+TEST(Ulwc1) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ float value = static_cast<float>(*i & 0xFFFFFFFF);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<float>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Ulwc1(f0, MemOperand(a0, in_offset), t0);
+ __ Uswc1(f0, MemOperand(a0, out_offset), t0);
+ }));
+ }
+ }
+ }
+}
+
+TEST(Uldc1) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ double value = static_cast<double>(*i);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<double>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Uldc1(f0, MemOperand(a0, in_offset), t0);
+ __ Usdc1(f0, MemOperand(a0, out_offset), t0);
+ }));
+ }
+ }
+ }
+}
+
#undef __
diff --git a/test/cctest/test-macro-assembler-mips64.cc b/test/cctest/test-macro-assembler-mips64.cc
index e251242..f0180c1 100644
--- a/test/cctest/test-macro-assembler-mips64.cc
+++ b/test/cctest/test-macro-assembler-mips64.cc
@@ -523,14 +523,14 @@
}
}
-static const std::vector<uint32_t> uint32_test_values() {
+static const std::vector<uint32_t> cvt_trunc_uint32_test_values() {
static const uint32_t kValues[] = {0x00000000, 0x00000001, 0x00ffff00,
0x7fffffff, 0x80000000, 0x80000001,
0x80ffff00, 0x8fffffff, 0xffffffff};
return std::vector<uint32_t>(&kValues[0], &kValues[arraysize(kValues)]);
}
-static const std::vector<int32_t> int32_test_values() {
+static const std::vector<int32_t> cvt_trunc_int32_test_values() {
static const int32_t kValues[] = {
static_cast<int32_t>(0x00000000), static_cast<int32_t>(0x00000001),
static_cast<int32_t>(0x00ffff00), static_cast<int32_t>(0x7fffffff),
@@ -540,7 +540,7 @@
return std::vector<int32_t>(&kValues[0], &kValues[arraysize(kValues)]);
}
-static const std::vector<uint64_t> uint64_test_values() {
+static const std::vector<uint64_t> cvt_trunc_uint64_test_values() {
static const uint64_t kValues[] = {
0x0000000000000000, 0x0000000000000001, 0x0000ffffffff0000,
0x7fffffffffffffff, 0x8000000000000000, 0x8000000000000001,
@@ -548,7 +548,7 @@
return std::vector<uint64_t>(&kValues[0], &kValues[arraysize(kValues)]);
}
-static const std::vector<int64_t> int64_test_values() {
+static const std::vector<int64_t> cvt_trunc_int64_test_values() {
static const int64_t kValues[] = {static_cast<int64_t>(0x0000000000000000),
static_cast<int64_t>(0x0000000000000001),
static_cast<int64_t>(0x0000ffffffff0000),
@@ -562,15 +562,32 @@
}
// Helper macros that can be used in FOR_INT32_INPUTS(i) { ... *i ... }
-#define FOR_INPUTS(ctype, itype, var) \
- std::vector<ctype> var##_vec = itype##_test_values(); \
+#define FOR_INPUTS(ctype, itype, var, test_vector) \
+ std::vector<ctype> var##_vec = test_vector(); \
for (std::vector<ctype>::iterator var = var##_vec.begin(); \
var != var##_vec.end(); ++var)
-#define FOR_INT32_INPUTS(var) FOR_INPUTS(int32_t, int32, var)
-#define FOR_INT64_INPUTS(var) FOR_INPUTS(int64_t, int64, var)
-#define FOR_UINT32_INPUTS(var) FOR_INPUTS(uint32_t, uint32, var)
-#define FOR_UINT64_INPUTS(var) FOR_INPUTS(uint64_t, uint64, var)
+#define FOR_INPUTS2(ctype, itype, var, var2, test_vector) \
+ std::vector<ctype> var##_vec = test_vector(); \
+ std::vector<ctype>::iterator var; \
+ std::vector<ctype>::reverse_iterator var2; \
+ for (var = var##_vec.begin(), var2 = var##_vec.rbegin(); \
+ var != var##_vec.end(); ++var, ++var2)
+
+#define FOR_ENUM_INPUTS(var, type, test_vector) \
+ FOR_INPUTS(enum type, type, var, test_vector)
+#define FOR_STRUCT_INPUTS(var, type, test_vector) \
+ FOR_INPUTS(struct type, type, var, test_vector)
+#define FOR_INT32_INPUTS(var, test_vector) \
+ FOR_INPUTS(int32_t, int32, var, test_vector)
+#define FOR_INT32_INPUTS2(var, var2, test_vector) \
+ FOR_INPUTS2(int32_t, int32, var, var2, test_vector)
+#define FOR_INT64_INPUTS(var, test_vector) \
+ FOR_INPUTS(int64_t, int64, var, test_vector)
+#define FOR_UINT32_INPUTS(var, test_vector) \
+ FOR_INPUTS(uint32_t, uint32, var, test_vector)
+#define FOR_UINT64_INPUTS(var, test_vector) \
+ FOR_INPUTS(uint64_t, uint64, var, test_vector)
template <typename RET_TYPE, typename IN_TYPE, typename Func>
RET_TYPE run_Cvt(IN_TYPE x, Func GenerateConvertInstructionFunc) {
@@ -600,7 +617,7 @@
TEST(Cvt_s_uw_Trunc_uw_s) {
CcTest::InitializeVM();
- FOR_UINT32_INPUTS(i) {
+ FOR_UINT32_INPUTS(i, cvt_trunc_uint32_test_values) {
uint32_t input = *i;
CHECK_EQ(static_cast<float>(input),
run_Cvt<uint64_t>(input, [](MacroAssembler* masm) {
@@ -613,7 +630,7 @@
TEST(Cvt_s_ul_Trunc_ul_s) {
CcTest::InitializeVM();
- FOR_UINT64_INPUTS(i) {
+ FOR_UINT64_INPUTS(i, cvt_trunc_uint64_test_values) {
uint64_t input = *i;
CHECK_EQ(static_cast<float>(input),
run_Cvt<uint64_t>(input, [](MacroAssembler* masm) {
@@ -625,7 +642,7 @@
TEST(Cvt_d_ul_Trunc_ul_d) {
CcTest::InitializeVM();
- FOR_UINT64_INPUTS(i) {
+ FOR_UINT64_INPUTS(i, cvt_trunc_uint64_test_values) {
uint64_t input = *i;
CHECK_EQ(static_cast<double>(input),
run_Cvt<uint64_t>(input, [](MacroAssembler* masm) {
@@ -637,7 +654,7 @@
TEST(cvt_d_l_Trunc_l_d) {
CcTest::InitializeVM();
- FOR_INT64_INPUTS(i) {
+ FOR_INT64_INPUTS(i, cvt_trunc_int64_test_values) {
int64_t input = *i;
CHECK_EQ(static_cast<double>(input),
run_Cvt<int64_t>(input, [](MacroAssembler* masm) {
@@ -650,7 +667,7 @@
TEST(cvt_d_l_Trunc_l_ud) {
CcTest::InitializeVM();
- FOR_INT64_INPUTS(i) {
+ FOR_INT64_INPUTS(i, cvt_trunc_int64_test_values) {
int64_t input = *i;
uint64_t abs_input = (input < 0) ? -input : input;
CHECK_EQ(static_cast<double>(abs_input),
@@ -664,7 +681,7 @@
TEST(cvt_d_w_Trunc_w_d) {
CcTest::InitializeVM();
- FOR_INT32_INPUTS(i) {
+ FOR_INT32_INPUTS(i, cvt_trunc_int32_test_values) {
int32_t input = *i;
CHECK_EQ(static_cast<double>(input),
run_Cvt<int64_t>(input, [](MacroAssembler* masm) {
@@ -677,6 +694,607 @@
}
}
+static const std::vector<int32_t> overflow_int32_test_values() {
+ static const int32_t kValues[] = {
+ static_cast<int32_t>(0xf0000000), static_cast<int32_t>(0x00000001),
+ static_cast<int32_t>(0xff000000), static_cast<int32_t>(0x0000f000),
+ static_cast<int32_t>(0x0f000000), static_cast<int32_t>(0x991234ab),
+ static_cast<int32_t>(0xb0ffff01), static_cast<int32_t>(0x00006fff),
+ static_cast<int32_t>(0xffffffff)};
+ return std::vector<int32_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+static const std::vector<int64_t> overflow_int64_test_values() {
+ static const int64_t kValues[] = {static_cast<int64_t>(0xf000000000000000),
+ static_cast<int64_t>(0x0000000000000001),
+ static_cast<int64_t>(0xff00000000000000),
+ static_cast<int64_t>(0x0000f00111111110),
+ static_cast<int64_t>(0x0f00001000000000),
+ static_cast<int64_t>(0x991234ab12a96731),
+ static_cast<int64_t>(0xb0ffff0f0f0f0f01),
+ static_cast<int64_t>(0x00006fffffffffff),
+ static_cast<int64_t>(0xffffffffffffffff)};
+ return std::vector<int64_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+enum OverflowBranchType {
+ kAddBranchOverflow,
+ kSubBranchOverflow,
+};
+
+struct OverflowRegisterCombination {
+ Register dst;
+ Register left;
+ Register right;
+ Register scratch;
+};
+
+static const std::vector<enum OverflowBranchType> overflow_branch_type() {
+ static const enum OverflowBranchType kValues[] = {kAddBranchOverflow,
+ kSubBranchOverflow};
+ return std::vector<enum OverflowBranchType>(&kValues[0],
+ &kValues[arraysize(kValues)]);
+}
+
+static const std::vector<struct OverflowRegisterCombination>
+overflow_register_combination() {
+ static const struct OverflowRegisterCombination kValues[] = {
+ {t0, t1, t2, t3}, {t0, t0, t2, t3}, {t0, t1, t0, t3}, {t0, t1, t1, t3}};
+ return std::vector<struct OverflowRegisterCombination>(
+ &kValues[0], &kValues[arraysize(kValues)]);
+}
+
+template <typename T>
+static bool IsAddOverflow(T x, T y) {
+ DCHECK(std::numeric_limits<T>::is_integer);
+ T max = std::numeric_limits<T>::max();
+ T min = std::numeric_limits<T>::min();
+
+ return (x > 0 && y > (max - x)) || (x < 0 && y < (min - x));
+}
+
+template <typename T>
+static bool IsSubOverflow(T x, T y) {
+ DCHECK(std::numeric_limits<T>::is_integer);
+ T max = std::numeric_limits<T>::max();
+ T min = std::numeric_limits<T>::min();
+
+ return (y > 0 && x < (min + y)) || (y < 0 && x > (max + y));
+}
+
+template <typename IN_TYPE, typename Func>
+static bool runOverflow(IN_TYPE valLeft, IN_TYPE valRight,
+ Func GenerateOverflowInstructions) {
+ typedef int64_t (*F_CVT)(char* x0, int x1, int x2, int x3, int x4);
+
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+ MacroAssembler assm(isolate, nullptr, 0,
+ v8::internal::CodeObjectRequired::kYes);
+ MacroAssembler* masm = &assm;
+
+ GenerateOverflowInstructions(masm, valLeft, valRight);
+ __ jr(ra);
+ __ nop();
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+ F_CVT f = FUNCTION_CAST<F_CVT>(code->entry());
+
+ int64_t r =
+ reinterpret_cast<int64_t>(CALL_GENERATED_CODE(isolate, f, 0, 0, 0, 0, 0));
+
+ DCHECK(r == 0 || r == 1);
+ return r;
+}
+
+TEST(BranchOverflowInt32BothLabels) {
+ FOR_INT32_INPUTS(i, overflow_int32_test_values) {
+ FOR_INT32_INPUTS(j, overflow_int32_test_values) {
+ FOR_ENUM_INPUTS(br, OverflowBranchType, overflow_branch_type) {
+ FOR_STRUCT_INPUTS(regComb, OverflowRegisterCombination,
+ overflow_register_combination) {
+ int32_t ii = *i;
+ int32_t jj = *j;
+ enum OverflowBranchType branchType = *br;
+ struct OverflowRegisterCombination rc = *regComb;
+
+ // If left and right register are same then left and right
+ // test values must also be same, otherwise we skip the test
+ if (rc.left.code() == rc.right.code()) {
+ if (ii != jj) {
+ continue;
+ }
+ }
+
+ bool res1 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label overflow, no_overflow, end;
+ __ li(rc.left, valLeft);
+ __ li(rc.right, valRight);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, rc.right, &overflow,
+ &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, rc.right, &overflow,
+ &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 2);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ bool res2 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label overflow, no_overflow, end;
+ __ li(rc.left, valLeft);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 2);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ switch (branchType) {
+ case kAddBranchOverflow:
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res2);
+ break;
+ case kSubBranchOverflow:
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res2);
+ break;
+ default:
+ UNREACHABLE();
+ }
+ }
+ }
+ }
+ }
+}
+
+TEST(BranchOverflowInt32LeftLabel) {
+ FOR_INT32_INPUTS(i, overflow_int32_test_values) {
+ FOR_INT32_INPUTS(j, overflow_int32_test_values) {
+ FOR_ENUM_INPUTS(br, OverflowBranchType, overflow_branch_type) {
+ FOR_STRUCT_INPUTS(regComb, OverflowRegisterCombination,
+ overflow_register_combination) {
+ int32_t ii = *i;
+ int32_t jj = *j;
+ enum OverflowBranchType branchType = *br;
+ struct OverflowRegisterCombination rc = *regComb;
+
+ // If left and right register are same then left and right
+ // test values must also be same, otherwise we skip the test
+ if (rc.left.code() == rc.right.code()) {
+ if (ii != jj) {
+ continue;
+ }
+ }
+
+ bool res1 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label overflow, end;
+ __ li(rc.left, valLeft);
+ __ li(rc.right, valRight);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, rc.right, &overflow, NULL,
+ rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, rc.right, &overflow, NULL,
+ rc.scratch);
+ break;
+ }
+ __ li(v0, 0);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ bind(&end);
+ });
+
+ bool res2 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label overflow, end;
+ __ li(rc.left, valLeft);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, NULL, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, NULL, rc.scratch);
+ break;
+ }
+ __ li(v0, 0);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ bind(&end);
+ });
+
+ switch (branchType) {
+ case kAddBranchOverflow:
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res2);
+ break;
+ case kSubBranchOverflow:
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res2);
+ break;
+ default:
+ UNREACHABLE();
+ }
+ }
+ }
+ }
+ }
+}
+
+TEST(BranchOverflowInt32RightLabel) {
+ FOR_INT32_INPUTS(i, overflow_int32_test_values) {
+ FOR_INT32_INPUTS(j, overflow_int32_test_values) {
+ FOR_ENUM_INPUTS(br, OverflowBranchType, overflow_branch_type) {
+ FOR_STRUCT_INPUTS(regComb, OverflowRegisterCombination,
+ overflow_register_combination) {
+ int32_t ii = *i;
+ int32_t jj = *j;
+ enum OverflowBranchType branchType = *br;
+ struct OverflowRegisterCombination rc = *regComb;
+
+ // If left and right register are same then left and right
+ // test values must also be same, otherwise we skip the test
+ if (rc.left.code() == rc.right.code()) {
+ if (ii != jj) {
+ continue;
+ }
+ }
+
+ bool res1 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label no_overflow, end;
+ __ li(rc.left, valLeft);
+ __ li(rc.right, valRight);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, rc.right, NULL,
+ &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, rc.right, NULL,
+ &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ bool res2 = runOverflow<int32_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int32_t valLeft,
+ int32_t valRight) {
+ Label no_overflow, end;
+ __ li(rc.left, valLeft);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ AddBranchOvf(rc.dst, rc.left, Operand(valRight), NULL,
+ &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ SubBranchOvf(rc.dst, rc.left, Operand(valRight), NULL,
+ &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ switch (branchType) {
+ case kAddBranchOverflow:
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsAddOverflow<int32_t>(ii, jj), res2);
+ break;
+ case kSubBranchOverflow:
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res1);
+ CHECK_EQ(IsSubOverflow<int32_t>(ii, jj), res2);
+ break;
+ default:
+ UNREACHABLE();
+ }
+ }
+ }
+ }
+ }
+}
+
+TEST(BranchOverflowInt64BothLabels) {
+ FOR_INT64_INPUTS(i, overflow_int64_test_values) {
+ FOR_INT64_INPUTS(j, overflow_int64_test_values) {
+ FOR_ENUM_INPUTS(br, OverflowBranchType, overflow_branch_type) {
+ FOR_STRUCT_INPUTS(regComb, OverflowRegisterCombination,
+ overflow_register_combination) {
+ int64_t ii = *i;
+ int64_t jj = *j;
+ enum OverflowBranchType branchType = *br;
+ struct OverflowRegisterCombination rc = *regComb;
+
+ // If left and right register are same then left and right
+ // test values must also be same, otherwise we skip the test
+ if (rc.left.code() == rc.right.code()) {
+ if (ii != jj) {
+ continue;
+ }
+ }
+
+ bool res1 = runOverflow<int64_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int64_t valLeft,
+ int64_t valRight) {
+ Label overflow, no_overflow, end;
+ __ li(rc.left, valLeft);
+ __ li(rc.right, valRight);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ DaddBranchOvf(rc.dst, rc.left, rc.right, &overflow,
+ &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ DsubBranchOvf(rc.dst, rc.left, rc.right, &overflow,
+ &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 2);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ bool res2 = runOverflow<int64_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int64_t valLeft,
+ int64_t valRight) {
+ Label overflow, no_overflow, end;
+ __ li(rc.left, valLeft);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ DaddBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ DsubBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 2);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ switch (branchType) {
+ case kAddBranchOverflow:
+ CHECK_EQ(IsAddOverflow<int64_t>(ii, jj), res1);
+ CHECK_EQ(IsAddOverflow<int64_t>(ii, jj), res2);
+ break;
+ case kSubBranchOverflow:
+ CHECK_EQ(IsSubOverflow<int64_t>(ii, jj), res1);
+ CHECK_EQ(IsSubOverflow<int64_t>(ii, jj), res2);
+ break;
+ default:
+ UNREACHABLE();
+ }
+ }
+ }
+ }
+ }
+}
+
+TEST(BranchOverflowInt64LeftLabel) {
+ FOR_INT64_INPUTS(i, overflow_int64_test_values) {
+ FOR_INT64_INPUTS(j, overflow_int64_test_values) {
+ FOR_ENUM_INPUTS(br, OverflowBranchType, overflow_branch_type) {
+ FOR_STRUCT_INPUTS(regComb, OverflowRegisterCombination,
+ overflow_register_combination) {
+ int64_t ii = *i;
+ int64_t jj = *j;
+ enum OverflowBranchType branchType = *br;
+ struct OverflowRegisterCombination rc = *regComb;
+
+ // If left and right register are same then left and right
+ // test values must also be same, otherwise we skip the test
+ if (rc.left.code() == rc.right.code()) {
+ if (ii != jj) {
+ continue;
+ }
+ }
+
+ bool res1 = runOverflow<int64_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int64_t valLeft,
+ int64_t valRight) {
+ Label overflow, end;
+ __ li(rc.left, valLeft);
+ __ li(rc.right, valRight);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ DaddBranchOvf(rc.dst, rc.left, rc.right, &overflow, NULL,
+ rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ DsubBranchOvf(rc.dst, rc.left, rc.right, &overflow, NULL,
+ rc.scratch);
+ break;
+ }
+ __ li(v0, 0);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ bind(&end);
+ });
+
+ bool res2 = runOverflow<int64_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int64_t valLeft,
+ int64_t valRight) {
+ Label overflow, end;
+ __ li(rc.left, valLeft);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ DaddBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, NULL, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ DsubBranchOvf(rc.dst, rc.left, Operand(valRight),
+ &overflow, NULL, rc.scratch);
+ break;
+ }
+ __ li(v0, 0);
+ __ Branch(&end);
+ __ bind(&overflow);
+ __ li(v0, 1);
+ __ bind(&end);
+ });
+
+ switch (branchType) {
+ case kAddBranchOverflow:
+ CHECK_EQ(IsAddOverflow<int64_t>(ii, jj), res1);
+ CHECK_EQ(IsAddOverflow<int64_t>(ii, jj), res2);
+ break;
+ case kSubBranchOverflow:
+ CHECK_EQ(IsSubOverflow<int64_t>(ii, jj), res1);
+ CHECK_EQ(IsSubOverflow<int64_t>(ii, jj), res2);
+ break;
+ default:
+ UNREACHABLE();
+ }
+ }
+ }
+ }
+ }
+}
+
+TEST(BranchOverflowInt64RightLabel) {
+ FOR_INT64_INPUTS(i, overflow_int64_test_values) {
+ FOR_INT64_INPUTS(j, overflow_int64_test_values) {
+ FOR_ENUM_INPUTS(br, OverflowBranchType, overflow_branch_type) {
+ FOR_STRUCT_INPUTS(regComb, OverflowRegisterCombination,
+ overflow_register_combination) {
+ int64_t ii = *i;
+ int64_t jj = *j;
+ enum OverflowBranchType branchType = *br;
+ struct OverflowRegisterCombination rc = *regComb;
+
+ // If left and right register are same then left and right
+ // test values must also be same, otherwise we skip the test
+ if (rc.left.code() == rc.right.code()) {
+ if (ii != jj) {
+ continue;
+ }
+ }
+
+ bool res1 = runOverflow<int64_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int64_t valLeft,
+ int64_t valRight) {
+ Label no_overflow, end;
+ __ li(rc.left, valLeft);
+ __ li(rc.right, valRight);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ DaddBranchOvf(rc.dst, rc.left, rc.right, NULL,
+ &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ DsubBranchOvf(rc.dst, rc.left, rc.right, NULL,
+ &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ bool res2 = runOverflow<int64_t>(
+ ii, jj, [branchType, rc](MacroAssembler* masm, int64_t valLeft,
+ int64_t valRight) {
+ Label no_overflow, end;
+ __ li(rc.left, valLeft);
+ switch (branchType) {
+ case kAddBranchOverflow:
+ __ DaddBranchOvf(rc.dst, rc.left, Operand(valRight), NULL,
+ &no_overflow, rc.scratch);
+ break;
+ case kSubBranchOverflow:
+ __ DsubBranchOvf(rc.dst, rc.left, Operand(valRight), NULL,
+ &no_overflow, rc.scratch);
+ break;
+ }
+ __ li(v0, 1);
+ __ Branch(&end);
+ __ bind(&no_overflow);
+ __ li(v0, 0);
+ __ bind(&end);
+ });
+
+ switch (branchType) {
+ case kAddBranchOverflow:
+ CHECK_EQ(IsAddOverflow<int64_t>(ii, jj), res1);
+ CHECK_EQ(IsAddOverflow<int64_t>(ii, jj), res2);
+ break;
+ case kSubBranchOverflow:
+ CHECK_EQ(IsSubOverflow<int64_t>(ii, jj), res1);
+ CHECK_EQ(IsSubOverflow<int64_t>(ii, jj), res2);
+ break;
+ default:
+ UNREACHABLE();
+ }
+ }
+ }
+ }
+ }
+}
+
TEST(min_max_nan) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
@@ -787,4 +1405,344 @@
}
}
+template <typename IN_TYPE, typename Func>
+bool run_Unaligned(char* memory_buffer, int32_t in_offset, int32_t out_offset,
+ IN_TYPE value, Func GenerateUnalignedInstructionFunc) {
+ typedef int32_t (*F_CVT)(char* x0, int x1, int x2, int x3, int x4);
+
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+ MacroAssembler assm(isolate, nullptr, 0,
+ v8::internal::CodeObjectRequired::kYes);
+ MacroAssembler* masm = &assm;
+ IN_TYPE res;
+
+ GenerateUnalignedInstructionFunc(masm, in_offset, out_offset);
+ __ jr(ra);
+ __ nop();
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+ F_CVT f = FUNCTION_CAST<F_CVT>(code->entry());
+
+ MemCopy(memory_buffer + in_offset, &value, sizeof(IN_TYPE));
+ CALL_GENERATED_CODE(isolate, f, memory_buffer, 0, 0, 0, 0);
+ MemCopy(&res, memory_buffer + out_offset, sizeof(IN_TYPE));
+
+ return res == value;
+}
+
+static const std::vector<uint64_t> unsigned_test_values() {
+ static const uint64_t kValues[] = {
+ 0x2180f18a06384414, 0x000a714532102277, 0xbc1acccf180649f0,
+ 0x8000000080008000, 0x0000000000000001, 0xffffffffffffffff,
+ };
+ return std::vector<uint64_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+static const std::vector<int32_t> unsigned_test_offset() {
+ static const int32_t kValues[] = {// value, offset
+ -132 * KB, -21 * KB, 0, 19 * KB, 135 * KB};
+ return std::vector<int32_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+static const std::vector<int32_t> unsigned_test_offset_increment() {
+ static const int32_t kValues[] = {-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5};
+ return std::vector<int32_t>(&kValues[0], &kValues[arraysize(kValues)]);
+}
+
+TEST(Ulh) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ uint16_t value = static_cast<uint64_t>(*i & 0xFFFF);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<uint16_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Ulh(v0, MemOperand(a0, in_offset));
+ __ Ush(v0, MemOperand(a0, out_offset), v0);
+ }));
+ CHECK_EQ(true, run_Unaligned<uint16_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ mov(t0, a0);
+ __ Ulh(a0, MemOperand(a0, in_offset));
+ __ Ush(a0, MemOperand(t0, out_offset), v0);
+ }));
+ CHECK_EQ(true, run_Unaligned<uint16_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ mov(t0, a0);
+ __ Ulhu(a0, MemOperand(a0, in_offset));
+ __ Ush(a0, MemOperand(t0, out_offset), t1);
+ }));
+ CHECK_EQ(true, run_Unaligned<uint16_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Ulhu(v0, MemOperand(a0, in_offset));
+ __ Ush(v0, MemOperand(a0, out_offset), t1);
+ }));
+ }
+ }
+ }
+}
+
+TEST(Ulh_bitextension) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ uint16_t value = static_cast<uint64_t>(*i & 0xFFFF);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<uint16_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ Label success, fail, end, different;
+ __ Ulh(t0, MemOperand(a0, in_offset));
+ __ Ulhu(t1, MemOperand(a0, in_offset));
+ __ Branch(&different, ne, t0, Operand(t1));
+
+ // If signed and unsigned values are same, check
+ // the upper bits to see if they are zero
+ __ sra(t0, t0, 15);
+ __ Branch(&success, eq, t0, Operand(zero_reg));
+ __ Branch(&fail);
+
+ // If signed and unsigned values are different,
+ // check that the upper bits are complementary
+ __ bind(&different);
+ __ sra(t1, t1, 15);
+ __ Branch(&fail, ne, t1, Operand(1));
+ __ sra(t0, t0, 15);
+ __ addiu(t0, t0, 1);
+ __ Branch(&fail, ne, t0, Operand(zero_reg));
+ // Fall through to success
+
+ __ bind(&success);
+ __ Ulh(t0, MemOperand(a0, in_offset));
+ __ Ush(t0, MemOperand(a0, out_offset), v0);
+ __ Branch(&end);
+ __ bind(&fail);
+ __ Ush(zero_reg, MemOperand(a0, out_offset), v0);
+ __ bind(&end);
+ }));
+ }
+ }
+ }
+}
+
+TEST(Ulw) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ uint32_t value = static_cast<uint32_t>(*i & 0xFFFFFFFF);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<uint32_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Ulw(v0, MemOperand(a0, in_offset));
+ __ Usw(v0, MemOperand(a0, out_offset));
+ }));
+ CHECK_EQ(true,
+ run_Unaligned<uint32_t>(
+ buffer_middle, in_offset, out_offset, (uint32_t)value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ mov(t0, a0);
+ __ Ulw(a0, MemOperand(a0, in_offset));
+ __ Usw(a0, MemOperand(t0, out_offset));
+ }));
+ CHECK_EQ(true, run_Unaligned<uint32_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Ulwu(v0, MemOperand(a0, in_offset));
+ __ Usw(v0, MemOperand(a0, out_offset));
+ }));
+ CHECK_EQ(true,
+ run_Unaligned<uint32_t>(
+ buffer_middle, in_offset, out_offset, (uint32_t)value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ mov(t0, a0);
+ __ Ulwu(a0, MemOperand(a0, in_offset));
+ __ Usw(a0, MemOperand(t0, out_offset));
+ }));
+ }
+ }
+ }
+}
+
+TEST(Ulw_extension) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ uint32_t value = static_cast<uint32_t>(*i & 0xFFFFFFFF);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<uint32_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ Label success, fail, end, different;
+ __ Ulw(t0, MemOperand(a0, in_offset));
+ __ Ulwu(t1, MemOperand(a0, in_offset));
+ __ Branch(&different, ne, t0, Operand(t1));
+
+ // If signed and unsigned values are same, check
+ // the upper bits to see if they are zero
+ __ dsra(t0, t0, 31);
+ __ Branch(&success, eq, t0, Operand(zero_reg));
+ __ Branch(&fail);
+
+ // If signed and unsigned values are different,
+ // check that the upper bits are complementary
+ __ bind(&different);
+ __ dsra(t1, t1, 31);
+ __ Branch(&fail, ne, t1, Operand(1));
+ __ dsra(t0, t0, 31);
+ __ daddiu(t0, t0, 1);
+ __ Branch(&fail, ne, t0, Operand(zero_reg));
+ // Fall through to success
+
+ __ bind(&success);
+ __ Ulw(t0, MemOperand(a0, in_offset));
+ __ Usw(t0, MemOperand(a0, out_offset));
+ __ Branch(&end);
+ __ bind(&fail);
+ __ Usw(zero_reg, MemOperand(a0, out_offset));
+ __ bind(&end);
+ }));
+ }
+ }
+ }
+}
+
+TEST(Uld) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ uint64_t value = *i;
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<uint64_t>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Uld(v0, MemOperand(a0, in_offset));
+ __ Usd(v0, MemOperand(a0, out_offset));
+ }));
+ CHECK_EQ(true,
+ run_Unaligned<uint64_t>(
+ buffer_middle, in_offset, out_offset, (uint32_t)value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ mov(t0, a0);
+ __ Uld(a0, MemOperand(a0, in_offset));
+ __ Usd(a0, MemOperand(t0, out_offset));
+ }));
+ }
+ }
+ }
+}
+
+TEST(Ulwc1) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ float value = static_cast<float>(*i & 0xFFFFFFFF);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<float>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Ulwc1(f0, MemOperand(a0, in_offset), t0);
+ __ Uswc1(f0, MemOperand(a0, out_offset), t0);
+ }));
+ }
+ }
+ }
+}
+
+TEST(Uldc1) {
+ CcTest::InitializeVM();
+
+ static const int kBufferSize = 300 * KB;
+ char memory_buffer[kBufferSize];
+ char* buffer_middle = memory_buffer + (kBufferSize / 2);
+
+ FOR_UINT64_INPUTS(i, unsigned_test_values) {
+ FOR_INT32_INPUTS2(j1, j2, unsigned_test_offset) {
+ FOR_INT32_INPUTS2(k1, k2, unsigned_test_offset_increment) {
+ double value = static_cast<double>(*i);
+ int32_t in_offset = *j1 + *k1;
+ int32_t out_offset = *j2 + *k2;
+
+ CHECK_EQ(true, run_Unaligned<double>(
+ buffer_middle, in_offset, out_offset, value,
+ [](MacroAssembler* masm, int32_t in_offset,
+ int32_t out_offset) {
+ __ Uldc1(f0, MemOperand(a0, in_offset), t0);
+ __ Usdc1(f0, MemOperand(a0, out_offset), t0);
+ }));
+ }
+ }
+ }
+}
+
#undef __
diff --git a/test/cctest/test-microtask-delivery.cc b/test/cctest/test-microtask-delivery.cc
deleted file mode 100644
index 3150ab8..0000000
--- a/test/cctest/test-microtask-delivery.cc
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright 2012 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following
-// disclaimer in the documentation and/or other materials provided
-// with the distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include "src/v8.h"
-
-#include "test/cctest/cctest.h"
-
-namespace i = v8::internal;
-
-namespace {
-class HarmonyIsolate {
- public:
- HarmonyIsolate() {
- v8::Isolate::CreateParams create_params;
- create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
- isolate_ = v8::Isolate::New(create_params);
- isolate_->Enter();
- }
-
- ~HarmonyIsolate() {
- isolate_->Exit();
- isolate_->Dispose();
- }
-
- v8::Isolate* GetIsolate() const { return isolate_; }
-
- private:
- v8::Isolate* isolate_;
-};
-} // namespace
-
-
-TEST(MicrotaskDeliverySimple) {
- i::FLAG_harmony_object_observe = true;
- HarmonyIsolate isolate;
- v8::HandleScope scope(isolate.GetIsolate());
- LocalContext context(isolate.GetIsolate());
- CompileRun(
- "var ordering = [];"
- "var resolver = {};"
- "function handler(resolve) { resolver.resolve = resolve; }"
- "var obj = {};"
- "var observeOrders = [1, 4];"
- "function observer() {"
- "ordering.push(observeOrders.shift());"
- "resolver.resolve();"
- "}"
- "var p = new Promise(handler);"
- "p.then(function() {"
- "ordering.push(2);"
- "}).then(function() {"
- "ordering.push(3);"
- "obj.id++;"
- "return new Promise(handler);"
- "}).then(function() {"
- "ordering.push(5);"
- "}).then(function() {"
- "ordering.push(6);"
- "});"
- "Object.observe(obj, observer);"
- "obj.id = 1;");
- CHECK_EQ(
- 6, CompileRun("ordering.length")->Int32Value(context.local()).FromJust());
- CHECK_EQ(1,
- CompileRun("ordering[0]")->Int32Value(context.local()).FromJust());
- CHECK_EQ(2,
- CompileRun("ordering[1]")->Int32Value(context.local()).FromJust());
- CHECK_EQ(3,
- CompileRun("ordering[2]")->Int32Value(context.local()).FromJust());
- CHECK_EQ(4,
- CompileRun("ordering[3]")->Int32Value(context.local()).FromJust());
- CHECK_EQ(5,
- CompileRun("ordering[4]")->Int32Value(context.local()).FromJust());
- CHECK_EQ(6,
- CompileRun("ordering[5]")->Int32Value(context.local()).FromJust());
-}
-
-
-TEST(MicrotaskPerIsolateState) {
- i::FLAG_harmony_object_observe = true;
- HarmonyIsolate isolate;
- v8::HandleScope scope(isolate.GetIsolate());
- LocalContext context1(isolate.GetIsolate());
- isolate.GetIsolate()->SetMicrotasksPolicy(v8::MicrotasksPolicy::kExplicit);
- CompileRun(
- "var obj = { calls: 0 };");
- v8::Local<v8::Value> obj = CompileRun("obj");
- {
- LocalContext context2(isolate.GetIsolate());
- context2->Global()
- ->Set(context2.local(),
- v8::String::NewFromUtf8(isolate.GetIsolate(), "obj",
- v8::NewStringType::kNormal)
- .ToLocalChecked(),
- obj)
- .FromJust();
- CompileRun(
- "var resolver = {};"
- "new Promise(function(resolve) {"
- "resolver.resolve = resolve;"
- "}).then(function() {"
- "obj.calls++;"
- "});"
- "(function() {"
- "resolver.resolve();"
- "})();");
- }
- {
- LocalContext context3(isolate.GetIsolate());
- context3->Global()
- ->Set(context3.local(),
- v8::String::NewFromUtf8(isolate.GetIsolate(), "obj",
- v8::NewStringType::kNormal)
- .ToLocalChecked(),
- obj)
- .FromJust();
- CompileRun(
- "var foo = { id: 1 };"
- "Object.observe(foo, function() {"
- "obj.calls++;"
- "});"
- "foo.id++;");
- }
- {
- LocalContext context4(isolate.GetIsolate());
- context4->Global()
- ->Set(context4.local(),
- v8::String::NewFromUtf8(isolate.GetIsolate(), "obj",
- v8::NewStringType::kNormal)
- .ToLocalChecked(),
- obj)
- .FromJust();
- isolate.GetIsolate()->RunMicrotasks();
- CHECK_EQ(2,
- CompileRun("obj.calls")->Int32Value(context4.local()).FromJust());
- }
-}
diff --git a/test/cctest/test-object-observe.cc b/test/cctest/test-object-observe.cc
deleted file mode 100644
index f17b8c0..0000000
--- a/test/cctest/test-object-observe.cc
+++ /dev/null
@@ -1,1078 +0,0 @@
-// Copyright 2012 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following
-// disclaimer in the documentation and/or other materials provided
-// with the distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include "src/v8.h"
-
-#include "test/cctest/cctest.h"
-
-using namespace v8;
-namespace i = v8::internal;
-
-inline int32_t ToInt32(v8::Local<v8::Value> value) {
- return value->Int32Value(v8::Isolate::GetCurrent()->GetCurrentContext())
- .FromJust();
-}
-
-
-TEST(PerIsolateState) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- LocalContext context1(CcTest::isolate());
-
- Local<Value> foo = v8_str("foo");
- context1->SetSecurityToken(foo);
-
- CompileRun(
- "var count = 0;"
- "var calls = 0;"
- "var observer = function(records) { count = records.length; calls++ };"
- "var obj = {};"
- "Object.observe(obj, observer);");
- Local<Value> observer = CompileRun("observer");
- Local<Value> obj = CompileRun("obj");
- Local<Value> notify_fun1 = CompileRun("(function() { obj.foo = 'bar'; })");
- Local<Value> notify_fun2;
- {
- LocalContext context2(CcTest::isolate());
- context2->SetSecurityToken(foo);
- context2->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- obj)
- .FromJust();
- notify_fun2 = CompileRun(
- "(function() { obj.foo = 'baz'; })");
- }
- Local<Value> notify_fun3;
- {
- LocalContext context3(CcTest::isolate());
- context3->SetSecurityToken(foo);
- context3->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- obj)
- .FromJust();
- notify_fun3 = CompileRun("(function() { obj.foo = 'bat'; })");
- }
- {
- LocalContext context4(CcTest::isolate());
- context4->SetSecurityToken(foo);
- context4->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8_str("observer"), observer)
- .FromJust();
- context4->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("fun1"),
- notify_fun1)
- .FromJust();
- context4->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("fun2"),
- notify_fun2)
- .FromJust();
- context4->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("fun3"),
- notify_fun3)
- .FromJust();
- CompileRun("fun1(); fun2(); fun3(); Object.deliverChangeRecords(observer)");
- }
- CHECK_EQ(1, ToInt32(CompileRun("calls")));
- CHECK_EQ(3, ToInt32(CompileRun("count")));
-}
-
-
-TEST(EndOfMicrotaskDelivery) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- LocalContext context(CcTest::isolate());
- CompileRun(
- "var obj = {};"
- "var count = 0;"
- "var observer = function(records) { count = records.length };"
- "Object.observe(obj, observer);"
- "obj.foo = 'bar';");
- CHECK_EQ(1, ToInt32(CompileRun("count")));
-}
-
-
-TEST(DeliveryOrdering) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- LocalContext context(CcTest::isolate());
- CompileRun(
- "var obj1 = {};"
- "var obj2 = {};"
- "var ordering = [];"
- "function observer2() { ordering.push(2); };"
- "function observer1() { ordering.push(1); };"
- "function observer3() { ordering.push(3); };"
- "Object.observe(obj1, observer1);"
- "Object.observe(obj1, observer2);"
- "Object.observe(obj1, observer3);"
- "obj1.foo = 'bar';");
- CHECK_EQ(3, ToInt32(CompileRun("ordering.length")));
- CHECK_EQ(1, ToInt32(CompileRun("ordering[0]")));
- CHECK_EQ(2, ToInt32(CompileRun("ordering[1]")));
- CHECK_EQ(3, ToInt32(CompileRun("ordering[2]")));
- CompileRun(
- "ordering = [];"
- "Object.observe(obj2, observer3);"
- "Object.observe(obj2, observer2);"
- "Object.observe(obj2, observer1);"
- "obj2.foo = 'baz'");
- CHECK_EQ(3, ToInt32(CompileRun("ordering.length")));
- CHECK_EQ(1, ToInt32(CompileRun("ordering[0]")));
- CHECK_EQ(2, ToInt32(CompileRun("ordering[1]")));
- CHECK_EQ(3, ToInt32(CompileRun("ordering[2]")));
-}
-
-
-TEST(DeliveryCallbackThrows) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- LocalContext context(CcTest::isolate());
- CompileRun(
- "var obj = {};"
- "var ordering = [];"
- "function observer1() { ordering.push(1); };"
- "function observer2() { ordering.push(2); };"
- "function observer_throws() {"
- " ordering.push(0);"
- " throw new Error();"
- " ordering.push(-1);"
- "};"
- "Object.observe(obj, observer_throws.bind());"
- "Object.observe(obj, observer1);"
- "Object.observe(obj, observer_throws.bind());"
- "Object.observe(obj, observer2);"
- "Object.observe(obj, observer_throws.bind());"
- "obj.foo = 'bar';");
- CHECK_EQ(5, ToInt32(CompileRun("ordering.length")));
- CHECK_EQ(0, ToInt32(CompileRun("ordering[0]")));
- CHECK_EQ(1, ToInt32(CompileRun("ordering[1]")));
- CHECK_EQ(0, ToInt32(CompileRun("ordering[2]")));
- CHECK_EQ(2, ToInt32(CompileRun("ordering[3]")));
- CHECK_EQ(0, ToInt32(CompileRun("ordering[4]")));
-}
-
-
-TEST(DeliveryChangesMutationInCallback) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- LocalContext context(CcTest::isolate());
- CompileRun(
- "var obj = {};"
- "var ordering = [];"
- "function observer1(records) {"
- " ordering.push(100 + records.length);"
- " records.push(11);"
- " records.push(22);"
- "};"
- "function observer2(records) {"
- " ordering.push(200 + records.length);"
- " records.push(33);"
- " records.push(44);"
- "};"
- "Object.observe(obj, observer1);"
- "Object.observe(obj, observer2);"
- "obj.foo = 'bar';");
- CHECK_EQ(2, ToInt32(CompileRun("ordering.length")));
- CHECK_EQ(101, ToInt32(CompileRun("ordering[0]")));
- CHECK_EQ(201, ToInt32(CompileRun("ordering[1]")));
-}
-
-
-TEST(DeliveryOrderingReentrant) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- LocalContext context(CcTest::isolate());
- CompileRun(
- "var obj = {};"
- "var reentered = false;"
- "var ordering = [];"
- "function observer1() { ordering.push(1); };"
- "function observer2() {"
- " if (!reentered) {"
- " obj.foo = 'baz';"
- " reentered = true;"
- " }"
- " ordering.push(2);"
- "};"
- "function observer3() { ordering.push(3); };"
- "Object.observe(obj, observer1);"
- "Object.observe(obj, observer2);"
- "Object.observe(obj, observer3);"
- "obj.foo = 'bar';");
- CHECK_EQ(5, ToInt32(CompileRun("ordering.length")));
- CHECK_EQ(1, ToInt32(CompileRun("ordering[0]")));
- CHECK_EQ(2, ToInt32(CompileRun("ordering[1]")));
- CHECK_EQ(3, ToInt32(CompileRun("ordering[2]")));
- // Note that we re-deliver to observers 1 and 2, while observer3
- // already received the second record during the first round.
- CHECK_EQ(1, ToInt32(CompileRun("ordering[3]")));
- CHECK_EQ(2, ToInt32(CompileRun("ordering[1]")));
-}
-
-
-TEST(DeliveryOrderingDeliverChangeRecords) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- LocalContext context(CcTest::isolate());
- CompileRun(
- "var obj = {};"
- "var ordering = [];"
- "function observer1() { ordering.push(1); if (!obj.b) obj.b = true };"
- "function observer2() { ordering.push(2); };"
- "Object.observe(obj, observer1);"
- "Object.observe(obj, observer2);"
- "obj.a = 1;"
- "Object.deliverChangeRecords(observer2);");
- CHECK_EQ(4, ToInt32(CompileRun("ordering.length")));
- // First, observer2 is called due to deliverChangeRecords
- CHECK_EQ(2, ToInt32(CompileRun("ordering[0]")));
- // Then, observer1 is called when the stack unwinds
- CHECK_EQ(1, ToInt32(CompileRun("ordering[1]")));
- // observer1's mutation causes both 1 and 2 to be reactivated,
- // with 1 having priority.
- CHECK_EQ(1, ToInt32(CompileRun("ordering[2]")));
- CHECK_EQ(2, ToInt32(CompileRun("ordering[3]")));
-}
-
-
-TEST(ObjectHashTableGrowth) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- // Initializing this context sets up initial hash tables.
- LocalContext context(CcTest::isolate());
- Local<Value> obj = CompileRun("obj = {};");
- Local<Value> observer = CompileRun(
- "var ran = false;"
- "(function() { ran = true })");
- {
- // As does initializing this context.
- LocalContext context2(CcTest::isolate());
- context2->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- obj)
- .FromJust();
- context2->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8_str("observer"), observer)
- .FromJust();
- CompileRun(
- "var objArr = [];"
- // 100 objects should be enough to make the hash table grow
- // (and thus relocate).
- "for (var i = 0; i < 100; ++i) {"
- " objArr.push({});"
- " Object.observe(objArr[objArr.length-1], function(){});"
- "}"
- "Object.observe(obj, observer);");
- }
- // obj is now marked "is_observed", but our map has moved.
- CompileRun("obj.foo = 'bar'");
- CHECK(CompileRun("ran")
- ->BooleanValue(v8::Isolate::GetCurrent()->GetCurrentContext())
- .FromJust());
-}
-
-
-struct RecordExpectation {
- Local<Value> object;
- const char* type;
- const char* name;
- Local<Value> old_value;
-};
-
-
-// TODO(adamk): Use this helper elsewhere in this file.
-static void ExpectRecords(v8::Isolate* isolate, Local<Value> records,
- const RecordExpectation expectations[], int num) {
- CHECK(records->IsArray());
- Local<Array> recordArray = records.As<Array>();
- CHECK_EQ(num, static_cast<int>(recordArray->Length()));
- for (int i = 0; i < num; ++i) {
- Local<Value> record =
- recordArray->Get(v8::Isolate::GetCurrent()->GetCurrentContext(), i)
- .ToLocalChecked();
- CHECK(record->IsObject());
- Local<Object> recordObj = record.As<Object>();
- Local<Value> value =
- recordObj->Get(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8_str("object"))
- .ToLocalChecked();
- CHECK(expectations[i].object->StrictEquals(value));
- value = recordObj->Get(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8_str("type"))
- .ToLocalChecked();
- CHECK(v8_str(expectations[i].type)
- ->Equals(v8::Isolate::GetCurrent()->GetCurrentContext(), value)
- .FromJust());
- if (strcmp("splice", expectations[i].type) != 0) {
- Local<Value> name =
- recordObj->Get(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8_str("name"))
- .ToLocalChecked();
- CHECK(v8_str(expectations[i].name)
- ->Equals(v8::Isolate::GetCurrent()->GetCurrentContext(), name)
- .FromJust());
- if (!expectations[i].old_value.IsEmpty()) {
- Local<Value> old_value =
- recordObj->Get(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8_str("oldValue"))
- .ToLocalChecked();
- CHECK(expectations[i]
- .old_value->Equals(
- v8::Isolate::GetCurrent()->GetCurrentContext(),
- old_value)
- .FromJust());
- }
- }
- }
-}
-
-#define EXPECT_RECORDS(records, expectations) \
- ExpectRecords(CcTest::isolate(), records, expectations, \
- arraysize(expectations))
-
-TEST(APITestBasicMutation) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* v8_isolate = CcTest::isolate();
- HandleScope scope(v8_isolate);
- LocalContext context(v8_isolate);
- Local<Object> obj = Local<Object>::Cast(
- CompileRun("var records = [];"
- "var obj = {};"
- "function observer(r) { [].push.apply(records, r); };"
- "Object.observe(obj, observer);"
- "obj"));
- obj->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("foo"),
- Number::New(v8_isolate, 7))
- .FromJust();
- obj->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), 1,
- Number::New(v8_isolate, 2))
- .FromJust();
- // CreateDataProperty should work just as well as Set
- obj->CreateDataProperty(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8_str("foo"), Number::New(v8_isolate, 3))
- .FromJust();
- obj->CreateDataProperty(v8::Isolate::GetCurrent()->GetCurrentContext(), 1,
- Number::New(v8_isolate, 4))
- .FromJust();
- // Setting an indexed element via the property setting method
- obj->Set(v8::Isolate::GetCurrent()->GetCurrentContext(),
- Number::New(v8_isolate, 1), Number::New(v8_isolate, 5))
- .FromJust();
- // Setting with a non-String, non-uint32 key
- obj->Set(v8::Isolate::GetCurrent()->GetCurrentContext(),
- Number::New(v8_isolate, 1.1), Number::New(v8_isolate, 6))
- .FromJust();
- obj->Delete(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("foo"))
- .FromJust();
- obj->Delete(v8::Isolate::GetCurrent()->GetCurrentContext(), 1).FromJust();
- obj->Delete(v8::Isolate::GetCurrent()->GetCurrentContext(),
- Number::New(v8_isolate, 1.1))
- .FromJust();
-
- // Force delivery
- // TODO(adamk): Should the above set methods trigger delivery themselves?
- CompileRun("void 0");
- CHECK_EQ(9, ToInt32(CompileRun("records.length")));
- const RecordExpectation expected_records[] = {
- {obj, "add", "foo", Local<Value>()},
- {obj, "add", "1", Local<Value>()},
- // Note: use 7 not 1 below, as the latter triggers a nifty VS10 compiler
- // bug
- // where instead of 1.0, a garbage value would be passed into Number::New.
- {obj, "update", "foo", Number::New(v8_isolate, 7)},
- {obj, "update", "1", Number::New(v8_isolate, 2)},
- {obj, "update", "1", Number::New(v8_isolate, 4)},
- {obj, "add", "1.1", Local<Value>()},
- {obj, "delete", "foo", Number::New(v8_isolate, 3)},
- {obj, "delete", "1", Number::New(v8_isolate, 5)},
- {obj, "delete", "1.1", Number::New(v8_isolate, 6)}};
- EXPECT_RECORDS(CompileRun("records"), expected_records);
-}
-
-
-TEST(HiddenPrototypeObservation) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* v8_isolate = CcTest::isolate();
- HandleScope scope(v8_isolate);
- LocalContext context(v8_isolate);
- Local<FunctionTemplate> tmpl = FunctionTemplate::New(v8_isolate);
- tmpl->SetHiddenPrototype(true);
- tmpl->InstanceTemplate()->Set(v8_str("foo"), Number::New(v8_isolate, 75));
- Local<Function> function =
- tmpl->GetFunction(v8::Isolate::GetCurrent()->GetCurrentContext())
- .ToLocalChecked();
- Local<Object> proto =
- function->NewInstance(v8::Isolate::GetCurrent()->GetCurrentContext())
- .ToLocalChecked();
- Local<Object> obj = Object::New(v8_isolate);
- obj->SetPrototype(v8::Isolate::GetCurrent()->GetCurrentContext(), proto)
- .FromJust();
- context->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"), obj)
- .FromJust();
- context->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("proto"),
- proto)
- .FromJust();
- CompileRun(
- "var records;"
- "function observer(r) { records = r; };"
- "Object.observe(obj, observer);"
- "obj.foo = 41;" // triggers a notification
- "proto.foo = 42;"); // does not trigger a notification
- const RecordExpectation expected_records[] = {
- { obj, "update", "foo", Number::New(v8_isolate, 75) }
- };
- EXPECT_RECORDS(CompileRun("records"), expected_records);
- obj->SetPrototype(v8::Isolate::GetCurrent()->GetCurrentContext(),
- Null(v8_isolate))
- .FromJust();
- CompileRun("obj.foo = 43");
- const RecordExpectation expected_records2[] = {
- {obj, "add", "foo", Local<Value>()}};
- EXPECT_RECORDS(CompileRun("records"), expected_records2);
- obj->SetPrototype(v8::Isolate::GetCurrent()->GetCurrentContext(), proto)
- .FromJust();
- CompileRun(
- "Object.observe(proto, observer);"
- "proto.bar = 1;"
- "Object.unobserve(obj, observer);"
- "obj.foo = 44;");
- const RecordExpectation expected_records3[] = {
- {proto, "add", "bar", Local<Value>()}
- // TODO(adamk): The below record should be emitted since proto is observed
- // and has been modified. Not clear if this happens in practice.
- // { proto, "update", "foo", Number::New(43) }
- };
- EXPECT_RECORDS(CompileRun("records"), expected_records3);
-}
-
-
-static int NumberOfElements(i::Handle<i::JSWeakMap> map) {
- return i::ObjectHashTable::cast(map->table())->NumberOfElements();
-}
-
-
-TEST(ObservationWeakMap) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- LocalContext context(CcTest::isolate());
- CompileRun(
- "var obj = {};"
- "Object.observe(obj, function(){});"
- "Object.getNotifier(obj);"
- "obj = null;");
- i::Isolate* i_isolate = CcTest::i_isolate();
- i::Handle<i::JSObject> observation_state =
- i_isolate->factory()->observation_state();
- i::Handle<i::JSWeakMap> callbackInfoMap = i::Handle<i::JSWeakMap>::cast(
- i::JSReceiver::GetProperty(i_isolate, observation_state,
- "callbackInfoMap")
- .ToHandleChecked());
- i::Handle<i::JSWeakMap> objectInfoMap = i::Handle<i::JSWeakMap>::cast(
- i::JSReceiver::GetProperty(i_isolate, observation_state, "objectInfoMap")
- .ToHandleChecked());
- i::Handle<i::JSWeakMap> notifierObjectInfoMap = i::Handle<i::JSWeakMap>::cast(
- i::JSReceiver::GetProperty(i_isolate, observation_state,
- "notifierObjectInfoMap")
- .ToHandleChecked());
- CHECK_EQ(1, NumberOfElements(callbackInfoMap));
- CHECK_EQ(1, NumberOfElements(objectInfoMap));
- CHECK_EQ(1, NumberOfElements(notifierObjectInfoMap));
- i_isolate->heap()->CollectAllGarbage();
- CHECK_EQ(0, NumberOfElements(callbackInfoMap));
- CHECK_EQ(0, NumberOfElements(objectInfoMap));
- CHECK_EQ(0, NumberOfElements(notifierObjectInfoMap));
-}
-
-
-static int TestObserveSecurity(Local<Context> observer_context,
- Local<Context> object_context,
- Local<Context> mutation_context) {
- Context::Scope observer_scope(observer_context);
- CompileRun("var records = null;"
- "var observer = function(r) { records = r };");
- Local<Value> observer = CompileRun("observer");
- {
- Context::Scope object_scope(object_context);
- object_context->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8_str("observer"), observer)
- .FromJust();
- CompileRun("var obj = {};"
- "obj.length = 0;"
- "Object.observe(obj, observer,"
- "['add', 'update', 'delete','reconfigure','splice']"
- ");");
- Local<Value> obj = CompileRun("obj");
- {
- Context::Scope mutation_scope(mutation_context);
- mutation_context->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- obj)
- .FromJust();
- CompileRun("obj.foo = 'bar';"
- "obj.foo = 'baz';"
- "delete obj.foo;"
- "Object.defineProperty(obj, 'bar', {value: 'bot'});"
- "Array.prototype.push.call(obj, 1, 2, 3);"
- "Array.prototype.splice.call(obj, 1, 2, 2, 4);"
- "Array.prototype.pop.call(obj);"
- "Array.prototype.shift.call(obj);");
- }
- }
- return ToInt32(CompileRun("records ? records.length : 0"));
-}
-
-
-TEST(ObserverSecurityAAA) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
- v8::Local<Context> contextA = Context::New(isolate);
- CHECK_EQ(8, TestObserveSecurity(contextA, contextA, contextA));
-}
-
-
-TEST(ObserverSecurityA1A2A3) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
-
- v8::Local<Context> contextA1 = Context::New(isolate);
- v8::Local<Context> contextA2 = Context::New(isolate);
- v8::Local<Context> contextA3 = Context::New(isolate);
-
- Local<Value> foo = v8_str("foo");
- contextA1->SetSecurityToken(foo);
- contextA2->SetSecurityToken(foo);
- contextA3->SetSecurityToken(foo);
-
- CHECK_EQ(8, TestObserveSecurity(contextA1, contextA2, contextA3));
-}
-
-
-TEST(ObserverSecurityAAB) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
- v8::Local<Context> contextA = Context::New(isolate);
- v8::Local<Context> contextB = Context::New(isolate);
- CHECK_EQ(0, TestObserveSecurity(contextA, contextA, contextB));
-}
-
-
-TEST(ObserverSecurityA1A2B) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
-
- v8::Local<Context> contextA1 = Context::New(isolate);
- v8::Local<Context> contextA2 = Context::New(isolate);
- v8::Local<Context> contextB = Context::New(isolate);
-
- Local<Value> foo = v8_str("foo");
- contextA1->SetSecurityToken(foo);
- contextA2->SetSecurityToken(foo);
-
- CHECK_EQ(0, TestObserveSecurity(contextA1, contextA2, contextB));
-}
-
-
-TEST(ObserverSecurityABA) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
- v8::Local<Context> contextA = Context::New(isolate);
- v8::Local<Context> contextB = Context::New(isolate);
- CHECK_EQ(0, TestObserveSecurity(contextA, contextB, contextA));
-}
-
-
-TEST(ObserverSecurityA1BA2) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
- v8::Local<Context> contextA1 = Context::New(isolate);
- v8::Local<Context> contextA2 = Context::New(isolate);
- v8::Local<Context> contextB = Context::New(isolate);
-
- Local<Value> foo = v8_str("foo");
- contextA1->SetSecurityToken(foo);
- contextA2->SetSecurityToken(foo);
-
- CHECK_EQ(0, TestObserveSecurity(contextA1, contextB, contextA2));
-}
-
-
-TEST(ObserverSecurityBAA) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
- v8::Local<Context> contextA = Context::New(isolate);
- v8::Local<Context> contextB = Context::New(isolate);
- CHECK_EQ(0, TestObserveSecurity(contextB, contextA, contextA));
-}
-
-
-TEST(ObserverSecurityBA1A2) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
- v8::Local<Context> contextA1 = Context::New(isolate);
- v8::Local<Context> contextA2 = Context::New(isolate);
- v8::Local<Context> contextB = Context::New(isolate);
-
- Local<Value> foo = v8_str("foo");
- contextA1->SetSecurityToken(foo);
- contextA2->SetSecurityToken(foo);
-
- CHECK_EQ(0, TestObserveSecurity(contextB, contextA1, contextA2));
-}
-
-
-TEST(ObserverSecurityNotify) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
- v8::Local<Context> contextA = Context::New(isolate);
- v8::Local<Context> contextB = Context::New(isolate);
-
- Context::Scope scopeA(contextA);
- CompileRun("var obj = {};"
- "var recordsA = null;"
- "var observerA = function(r) { recordsA = r };"
- "Object.observe(obj, observerA);");
- Local<Value> obj = CompileRun("obj");
-
- {
- Context::Scope scopeB(contextB);
- contextB->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- obj)
- .FromJust();
- CompileRun("var recordsB = null;"
- "var observerB = function(r) { recordsB = r };"
- "Object.observe(obj, observerB);");
- }
-
- CompileRun("var notifier = Object.getNotifier(obj);"
- "notifier.notify({ type: 'update' });");
- CHECK_EQ(1, ToInt32(CompileRun("recordsA ? recordsA.length : 0")));
-
- {
- Context::Scope scopeB(contextB);
- CHECK_EQ(0, ToInt32(CompileRun("recordsB ? recordsB.length : 0")));
- }
-}
-
-
-TEST(HiddenPropertiesLeakage) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- LocalContext context(CcTest::isolate());
- CompileRun("var obj = {};"
- "var records = null;"
- "var observer = function(r) { records = r };"
- "Object.observe(obj, observer);");
- Local<Value> obj =
- context->Global()
- ->Get(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"))
- .ToLocalChecked();
- Local<Object>::Cast(obj)
- ->SetPrivate(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8::Private::New(CcTest::isolate(), v8_str("foo")),
- Null(CcTest::isolate()))
- .FromJust();
- CompileRun(""); // trigger delivery
- CHECK(CompileRun("records")->IsNull());
-}
-
-
-TEST(GetNotifierFromOtherContext) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- LocalContext context(CcTest::isolate());
- CompileRun("var obj = {};");
- Local<Value> instance = CompileRun("obj");
- {
- LocalContext context2(CcTest::isolate());
- context2->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- instance)
- .FromJust();
- CHECK(CompileRun("Object.getNotifier(obj)")->IsNull());
- }
-}
-
-
-TEST(GetNotifierFromOtherOrigin) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- Local<Value> foo = v8_str("foo");
- Local<Value> bar = v8_str("bar");
- LocalContext context(CcTest::isolate());
- context->SetSecurityToken(foo);
- CompileRun("var obj = {};");
- Local<Value> instance = CompileRun("obj");
- {
- LocalContext context2(CcTest::isolate());
- context2->SetSecurityToken(bar);
- context2->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- instance)
- .FromJust();
- CHECK(CompileRun("Object.getNotifier(obj)")->IsNull());
- }
-}
-
-
-TEST(GetNotifierFromSameOrigin) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- Local<Value> foo = v8_str("foo");
- LocalContext context(CcTest::isolate());
- context->SetSecurityToken(foo);
- CompileRun("var obj = {};");
- Local<Value> instance = CompileRun("obj");
- {
- LocalContext context2(CcTest::isolate());
- context2->SetSecurityToken(foo);
- context2->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- instance)
- .FromJust();
- CHECK(CompileRun("Object.getNotifier(obj)")->IsObject());
- }
-}
-
-
-static int GetGlobalObjectsCount() {
- int count = 0;
- i::HeapIterator it(CcTest::heap());
- for (i::HeapObject* object = it.next(); object != NULL; object = it.next())
- if (object->IsJSGlobalObject()) {
- i::JSGlobalObject* g = i::JSGlobalObject::cast(object);
- // Skip dummy global object.
- if (i::GlobalDictionary::cast(g->properties())->NumberOfElements() != 0) {
- count++;
- }
- }
- // Subtract one to compensate for the code stub context that is always present
- return count - 1;
-}
-
-
-static void CheckSurvivingGlobalObjectsCount(int expected) {
- // We need to collect all garbage twice to be sure that everything
- // has been collected. This is because inline caches are cleared in
- // the first garbage collection but some of the maps have already
- // been marked at that point. Therefore some of the maps are not
- // collected until the second garbage collection.
- CcTest::heap()->CollectAllGarbage();
- CcTest::heap()->CollectAllGarbage(i::Heap::kMakeHeapIterableMask);
- int count = GetGlobalObjectsCount();
-#ifdef DEBUG
- if (count != expected) CcTest::heap()->TracePathToGlobal();
-#endif
- CHECK_EQ(expected, count);
-}
-
-
-TEST(DontLeakContextOnObserve) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- Local<Value> foo = v8_str("foo");
- LocalContext context(CcTest::isolate());
- context->SetSecurityToken(foo);
- CompileRun("var obj = {};");
- Local<Value> object = CompileRun("obj");
- {
- HandleScope scope(CcTest::isolate());
- LocalContext context2(CcTest::isolate());
- context2->SetSecurityToken(foo);
- context2->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- object)
- .FromJust();
- CompileRun("function observer() {};"
- "Object.observe(obj, observer, ['foo', 'bar', 'baz']);"
- "Object.unobserve(obj, observer);");
- }
-
- CcTest::isolate()->ContextDisposedNotification();
- CheckSurvivingGlobalObjectsCount(0);
-}
-
-
-TEST(DontLeakContextOnGetNotifier) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- Local<Value> foo = v8_str("foo");
- LocalContext context(CcTest::isolate());
- context->SetSecurityToken(foo);
- CompileRun("var obj = {};");
- Local<Value> object = CompileRun("obj");
- {
- HandleScope scope(CcTest::isolate());
- LocalContext context2(CcTest::isolate());
- context2->SetSecurityToken(foo);
- context2->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- object)
- .FromJust();
- CompileRun("Object.getNotifier(obj);");
- }
-
- CcTest::isolate()->ContextDisposedNotification();
- CheckSurvivingGlobalObjectsCount(0);
-}
-
-
-TEST(DontLeakContextOnNotifierPerformChange) {
- i::FLAG_harmony_object_observe = true;
- HandleScope scope(CcTest::isolate());
- Local<Value> foo = v8_str("foo");
- LocalContext context(CcTest::isolate());
- context->SetSecurityToken(foo);
- CompileRun("var obj = {};");
- Local<Value> object = CompileRun("obj");
- Local<Value> notifier = CompileRun("Object.getNotifier(obj)");
- {
- HandleScope scope(CcTest::isolate());
- LocalContext context2(CcTest::isolate());
- context2->SetSecurityToken(foo);
- context2->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- object)
- .FromJust();
- context2->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8_str("notifier"), notifier)
- .FromJust();
- CompileRun("var obj2 = {};"
- "var notifier2 = Object.getNotifier(obj2);"
- "notifier2.performChange.call("
- "notifier, 'foo', function(){})");
- }
-
- CcTest::isolate()->ContextDisposedNotification();
- CheckSurvivingGlobalObjectsCount(0);
-}
-
-
-static void ObserverCallback(const FunctionCallbackInfo<Value>& args) {
- *static_cast<int*>(Local<External>::Cast(args.Data())->Value()) =
- Local<Array>::Cast(args[0])->Length();
-}
-
-
-TEST(ObjectObserveCallsCppFunction) {
- i::FLAG_harmony_object_observe = true;
- Isolate* isolate = CcTest::isolate();
- HandleScope scope(isolate);
- LocalContext context(isolate);
- int numRecordsSent = 0;
- Local<Function> observer =
- Function::New(CcTest::isolate()->GetCurrentContext(), ObserverCallback,
- External::New(isolate, &numRecordsSent))
- .ToLocalChecked();
- context->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("observer"),
- observer)
- .FromJust();
- CompileRun(
- "var obj = {};"
- "Object.observe(obj, observer);"
- "obj.foo = 1;"
- "obj.bar = 2;");
- CHECK_EQ(2, numRecordsSent);
-}
-
-
-TEST(ObjectObserveCallsFunctionTemplateInstance) {
- i::FLAG_harmony_object_observe = true;
- Isolate* isolate = CcTest::isolate();
- HandleScope scope(isolate);
- LocalContext context(isolate);
- int numRecordsSent = 0;
- Local<FunctionTemplate> tmpl = FunctionTemplate::New(
- isolate, ObserverCallback, External::New(isolate, &numRecordsSent));
- Local<Function> function =
- tmpl->GetFunction(v8::Isolate::GetCurrent()->GetCurrentContext())
- .ToLocalChecked();
- context->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("observer"),
- function)
- .FromJust();
- CompileRun(
- "var obj = {};"
- "Object.observe(obj, observer);"
- "obj.foo = 1;"
- "obj.bar = 2;");
- CHECK_EQ(2, numRecordsSent);
-}
-
-
-static void AccessorGetter(Local<Name> property,
- const PropertyCallbackInfo<Value>& info) {
- info.GetReturnValue().Set(Integer::New(info.GetIsolate(), 42));
-}
-
-
-static void AccessorSetter(Local<Name> property, Local<Value> value,
- const PropertyCallbackInfo<void>& info) {
- info.GetReturnValue().SetUndefined();
-}
-
-
-TEST(APIAccessorsShouldNotNotify) {
- i::FLAG_harmony_object_observe = true;
- Isolate* isolate = CcTest::isolate();
- HandleScope handle_scope(isolate);
- LocalContext context(isolate);
- Local<Object> object = Object::New(isolate);
- object->SetAccessor(v8::Isolate::GetCurrent()->GetCurrentContext(),
- v8_str("accessor"), &AccessorGetter, &AccessorSetter)
- .FromJust();
- context->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- object)
- .FromJust();
- CompileRun(
- "var records = null;"
- "Object.observe(obj, function(r) { records = r });"
- "obj.accessor = 43;");
- CHECK(CompileRun("records")->IsNull());
- CompileRun("Object.defineProperty(obj, 'accessor', { value: 44 });");
- CHECK(CompileRun("records")->IsNull());
-}
-
-
-namespace {
-
-int* global_use_counts = NULL;
-
-void MockUseCounterCallback(v8::Isolate* isolate,
- v8::Isolate::UseCounterFeature feature) {
- ++global_use_counts[feature];
-}
-}
-
-
-TEST(UseCountObjectObserve) {
- i::FLAG_harmony_object_observe = true;
- i::Isolate* isolate = CcTest::i_isolate();
- i::HandleScope scope(isolate);
- LocalContext env;
- int use_counts[v8::Isolate::kUseCounterFeatureCount] = {};
- global_use_counts = use_counts;
- CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
- CompileRun(
- "var obj = {};"
- "Object.observe(obj, function(){})");
- CHECK_EQ(1, use_counts[v8::Isolate::kObjectObserve]);
- CompileRun(
- "var obj2 = {};"
- "Object.observe(obj2, function(){})");
- // Only counts the first use of observe in a given context.
- CHECK_EQ(1, use_counts[v8::Isolate::kObjectObserve]);
- {
- LocalContext env2;
- CompileRun(
- "var obj = {};"
- "Object.observe(obj, function(){})");
- }
- // Counts different contexts separately.
- CHECK_EQ(2, use_counts[v8::Isolate::kObjectObserve]);
-}
-
-
-TEST(UseCountObjectGetNotifier) {
- i::FLAG_harmony_object_observe = true;
- i::Isolate* isolate = CcTest::i_isolate();
- i::HandleScope scope(isolate);
- LocalContext env;
- int use_counts[v8::Isolate::kUseCounterFeatureCount] = {};
- global_use_counts = use_counts;
- CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
- CompileRun("var obj = {}");
- CompileRun("Object.getNotifier(obj)");
- CHECK_EQ(1, use_counts[v8::Isolate::kObjectObserve]);
-}
-
-static bool NamedAccessCheckAlwaysAllow(Local<v8::Context> accessing_context,
- Local<v8::Object> accessed_object,
- Local<v8::Value> data) {
- return true;
-}
-
-
-TEST(DisallowObserveAccessCheckedObject) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
- LocalContext env;
- v8::Local<v8::ObjectTemplate> object_template =
- v8::ObjectTemplate::New(isolate);
- object_template->SetAccessCheckCallback(NamedAccessCheckAlwaysAllow);
- Local<Object> new_instance =
- object_template->NewInstance(
- v8::Isolate::GetCurrent()->GetCurrentContext())
- .ToLocalChecked();
- env->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- new_instance)
- .FromJust();
- v8::TryCatch try_catch(isolate);
- CompileRun("Object.observe(obj, function(){})");
- CHECK(try_catch.HasCaught());
-}
-
-
-TEST(DisallowGetNotifierAccessCheckedObject) {
- i::FLAG_harmony_object_observe = true;
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
- LocalContext env;
- v8::Local<v8::ObjectTemplate> object_template =
- v8::ObjectTemplate::New(isolate);
- object_template->SetAccessCheckCallback(NamedAccessCheckAlwaysAllow);
- Local<Object> new_instance =
- object_template->NewInstance(
- v8::Isolate::GetCurrent()->GetCurrentContext())
- .ToLocalChecked();
- env->Global()
- ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
- new_instance)
- .FromJust();
- v8::TryCatch try_catch(isolate);
- CompileRun("Object.getNotifier(obj)");
- CHECK(try_catch.HasCaught());
-}
diff --git a/test/cctest/test-parsing.cc b/test/cctest/test-parsing.cc
index ae278d8..36f7293 100644
--- a/test/cctest/test-parsing.cc
+++ b/test/cctest/test-parsing.cc
@@ -1070,7 +1070,6 @@
i::Zone zone(CcTest::i_isolate()->allocator());
i::ParseInfo info(&zone, script);
i::Parser parser(&info);
- parser.set_allow_harmony_sloppy(true);
info.set_global();
CHECK(parser.Parse(&info));
CHECK(i::Rewriter::Rewrite(&info));
@@ -1122,13 +1121,11 @@
i::ParseInfo info(handles.main_zone(), script);
i::Parser parser(&info);
- parser.set_allow_harmony_sloppy(true);
info.set_global();
info.set_lazy(false);
info.set_allow_lazy_parsing(false);
info.set_toplevel(true);
- i::CompilationInfo compilation_info(&info);
CHECK(i::Compiler::ParseAndAnalyze(&info));
CHECK(info.scope()->declarations()->length() == 1);
@@ -1438,7 +1435,6 @@
i::ParseInfo info(&zone, script);
info.set_allow_lazy_parsing();
i::Parser parser(&info);
- parser.set_allow_harmony_sloppy(true);
parser.Parse(&info);
function = info.literal();
CHECK_NOT_NULL(function);
@@ -1509,12 +1505,11 @@
enum ParserFlag {
kAllowLazy,
kAllowNatives,
- kAllowHarmonySloppy,
- kAllowHarmonySloppyLet,
- kAllowHarmonyNewTarget,
kAllowHarmonyFunctionSent,
kAllowHarmonyRestrictiveDeclarations,
- kAllowHarmonyExponentiationOperator
+ kAllowHarmonyExponentiationOperator,
+ kAllowHarmonyForIn,
+ kAllowHarmonyAsyncAwait
};
enum ParserSyncTestResult {
@@ -1528,28 +1523,29 @@
i::EnumSet<ParserFlag> flags) {
parser->set_allow_lazy(flags.Contains(kAllowLazy));
parser->set_allow_natives(flags.Contains(kAllowNatives));
- parser->set_allow_harmony_sloppy(flags.Contains(kAllowHarmonySloppy));
- parser->set_allow_harmony_sloppy_let(flags.Contains(kAllowHarmonySloppyLet));
parser->set_allow_harmony_function_sent(
flags.Contains(kAllowHarmonyFunctionSent));
parser->set_allow_harmony_restrictive_declarations(
flags.Contains(kAllowHarmonyRestrictiveDeclarations));
parser->set_allow_harmony_exponentiation_operator(
flags.Contains(kAllowHarmonyExponentiationOperator));
+ parser->set_allow_harmony_for_in(flags.Contains(kAllowHarmonyForIn));
+ parser->set_allow_harmony_async_await(
+ flags.Contains(kAllowHarmonyAsyncAwait));
}
void TestParserSyncWithFlags(i::Handle<i::String> source,
i::EnumSet<ParserFlag> flags,
ParserSyncTestResult result,
- bool is_module = false) {
+ bool is_module = false,
+ bool test_preparser = true) {
i::Isolate* isolate = CcTest::i_isolate();
i::Factory* factory = isolate->factory();
uintptr_t stack_limit = isolate->stack_guard()->real_climit();
int preparser_materialized_literals = -1;
int parser_materialized_literals = -2;
- bool test_preparser = !is_module;
// Preparse the data.
i::CompleteParserRecorder log;
@@ -1563,8 +1559,8 @@
stack_limit);
SetParserFlags(&preparser, flags);
scanner.Initialize(&stream);
- i::PreParser::PreParseResult result = preparser.PreParseProgram(
- &preparser_materialized_literals);
+ i::PreParser::PreParseResult result =
+ preparser.PreParseProgram(&preparser_materialized_literals, is_module);
CHECK_EQ(i::PreParser::kPreParseSuccess, result);
}
bool preparse_error = log.HasError();
@@ -1674,7 +1670,7 @@
size_t always_true_flags_length = 0,
const ParserFlag* always_false_flags = NULL,
size_t always_false_flags_length = 0,
- bool is_module = false) {
+ bool is_module = false, bool test_preparser = true) {
i::Handle<i::String> str =
CcTest::i_isolate()->factory()->NewStringFromAsciiChecked(source);
for (int bits = 0; bits < (1 << varying_flags_length); bits++) {
@@ -1691,7 +1687,7 @@
++flag_index) {
flags.Remove(always_false_flags[flag_index]);
}
- TestParserSyncWithFlags(str, flags, result, is_module);
+ TestParserSyncWithFlags(str, flags, result, is_module, test_preparser);
}
}
@@ -1839,7 +1835,8 @@
const ParserFlag* always_true_flags = NULL,
int always_true_len = 0,
const ParserFlag* always_false_flags = NULL,
- int always_false_len = 0, bool is_module = false) {
+ int always_false_len = 0, bool is_module = false,
+ bool test_preparser = true) {
v8::HandleScope handles(CcTest::isolate());
v8::Local<v8::Context> context = v8::Context::New(CcTest::isolate());
v8::Context::Scope context_scope(context);
@@ -1894,7 +1891,7 @@
CHECK(length == kProgramSize);
TestParserSync(program.start(), flags, flags_len, result,
always_true_flags, always_true_len, always_false_flags,
- always_false_len, is_module);
+ always_false_len, is_module, test_preparser);
}
}
delete[] generated_flags;
@@ -1908,10 +1905,11 @@
const ParserFlag* always_true_flags = NULL,
int always_true_len = 0,
const ParserFlag* always_false_flags = NULL,
- int always_false_len = 0) {
+ int always_false_len = 0,
+ bool test_preparser = true) {
RunParserSyncTest(context_data, statement_data, result, flags, flags_len,
always_true_flags, always_true_len, always_false_flags,
- always_false_len, true);
+ always_false_len, true, test_preparser);
}
@@ -2017,25 +2015,28 @@
RunParserSyncTest(context_data, statement_data, kSuccess);
}
+#define FUTURE_STRICT_RESERVED_WORDS_NO_LET(V) \
+ V(implements) \
+ V(interface) \
+ V(package) \
+ V(private) \
+ V(protected) \
+ V(public) \
+ V(static) \
+ V(yield)
#define FUTURE_STRICT_RESERVED_WORDS(V) \
- V(implements) \
- V(interface) \
V(let) \
- V(package) \
- V(private) \
- V(protected) \
- V(public) \
- V(static) \
- V(yield)
+ FUTURE_STRICT_RESERVED_WORDS_NO_LET(V)
+#define LIMITED_FUTURE_STRICT_RESERVED_WORDS_NO_LET(V) \
+ V(implements) \
+ V(static) \
+ V(yield)
#define LIMITED_FUTURE_STRICT_RESERVED_WORDS(V) \
- V(implements) \
V(let) \
- V(static) \
- V(yield)
-
+ LIMITED_FUTURE_STRICT_RESERVED_WORDS_NO_LET(V)
#define FUTURE_STRICT_RESERVED_STATEMENTS(NAME) \
"var " #NAME ";", \
@@ -2051,26 +2052,53 @@
"++" #NAME ";", \
#NAME " ++;",
+// clang-format off
+#define FUTURE_STRICT_RESERVED_LEX_BINDINGS(NAME) \
+ "let " #NAME ";", \
+ "for (let " #NAME "; false; ) {}", \
+ "for (let " #NAME " in {}) {}", \
+ "for (let " #NAME " of []) {}", \
+ "const " #NAME " = null;", \
+ "for (const " #NAME " = null; false; ) {}", \
+ "for (const " #NAME " in {}) {}", \
+ "for (const " #NAME " of []) {}",
+// clang-format on
TEST(ErrorsFutureStrictReservedWords) {
// Tests that both preparsing and parsing produce the right kind of errors for
// using future strict reserved words as identifiers. Without the strict mode,
// it's ok to use future strict reserved words as identifiers. With the strict
// mode, it isn't.
- const char* context_data[][2] = {
+ const char* strict_contexts[][2] = {
{"function test_func() {\"use strict\"; ", "}"},
{"() => { \"use strict\"; ", "}"},
{NULL, NULL}};
+ // clang-format off
const char* statement_data[] {
LIMITED_FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_STATEMENTS)
+ LIMITED_FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_LEX_BINDINGS)
NULL
};
+ // clang-format on
- RunParserSyncTest(context_data, statement_data, kError);
+ RunParserSyncTest(strict_contexts, statement_data, kError);
+
+ // From ES2015, 13.3.1.1 Static Semantics: Early Errors:
+ //
+ // > LexicalDeclaration : LetOrConst BindingList ;
+ // >
+ // > - It is a Syntax Error if the BoundNames of BindingList contains "let".
+ const char* non_strict_contexts[][2] = {{"", ""},
+ {"function test_func() {", "}"},
+ {"() => {", "}"},
+ {NULL, NULL}};
+ const char* invalid_statements[] = {FUTURE_STRICT_RESERVED_LEX_BINDINGS("let")
+ NULL};
+
+ RunParserSyncTest(non_strict_contexts, invalid_statements, kError);
}
-
#undef LIMITED_FUTURE_STRICT_RESERVED_WORDS
@@ -2082,10 +2110,13 @@
{ NULL, NULL }
};
+ // clang-format off
const char* statement_data[] = {
FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_STATEMENTS)
+ FUTURE_STRICT_RESERVED_WORDS_NO_LET(FUTURE_STRICT_RESERVED_LEX_BINDINGS)
NULL
};
+ // clang-format on
RunParserSyncTest(context_data, statement_data, kSuccess);
}
@@ -2349,9 +2380,7 @@
};
// clang-format on
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, statement_data, kSuccess);
}
@@ -2407,6 +2436,10 @@
"var {foo: yield 24} = {a: 42};",
"[yield 24] = [42];",
"({a: yield 24} = {a: 42});",
+ "for (yield 'x' in {});",
+ "for (yield 'x' of {});",
+ "for (yield 'x' in {} in {});",
+ "for (yield 'x' in {} of {});",
"class C extends yield { }",
NULL
};
@@ -3949,11 +3982,7 @@
NULL
};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, statement_data, kSuccess);
}
@@ -3980,9 +4009,7 @@
NULL
};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, expression_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, expression_data, kError);
}
@@ -3996,9 +4023,7 @@
NULL
};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, success_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, success_data, kSuccess);
const char* error_data[] = {
"class C { constructor() { super(); } }",
@@ -4020,8 +4045,7 @@
NULL
};
- RunParserSyncTest(context_data, error_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, error_data, kError);
}
@@ -4046,9 +4070,7 @@
NULL
};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, expression_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, expression_data, kSuccess);
}
@@ -4079,9 +4101,7 @@
NULL
};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, statement_data, kError);
}
@@ -4119,11 +4139,7 @@
NULL
};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, statement_data, kError);
}
@@ -4336,9 +4352,7 @@
"class name extends class base {} {}",
NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, class_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_data, kSuccess);
}
@@ -4412,11 +4426,7 @@
NULL};
// clang-format on
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_body_data, kSuccess);
}
@@ -4469,11 +4479,7 @@
"finally",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, name_data, kSuccess);
}
@@ -4499,11 +4505,7 @@
"class { m() {}, n() {} }", // No commas allowed.
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_data, kError);
}
@@ -4535,11 +4537,7 @@
"class name { *static m() {} }",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_data, kError);
}
@@ -4564,11 +4562,7 @@
"yield",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_name, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_name, kError);
}
@@ -4596,11 +4590,7 @@
"yield",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_name, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_name, kError);
}
@@ -4623,11 +4613,7 @@
"static *'prot\\u006ftype'() {}",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_body_data, kError);
}
@@ -4649,11 +4635,7 @@
"*'c\\u006fnstructor'() {}",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_body_data, kError);
}
@@ -4670,11 +4652,7 @@
"static *constructor() {}",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_body_data, kSuccess);
}
@@ -4687,11 +4665,7 @@
"constructor() {}; constructor() {}",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_body_data, kError);
}
@@ -4708,11 +4682,7 @@
"get m() {}; set m(_) {}; get m() {}; set m(_) {};",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_body_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_body_data, kSuccess);
}
@@ -4727,11 +4697,7 @@
"class C { *method() { with ({}) {} } }",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy
- };
- RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, class_body_data, kError);
}
@@ -4869,10 +4835,7 @@
"for(let x in {}, {}) {}", "for(const x in {}, {}) {}",
NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
- kAllowHarmonySloppyLet};
- RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kSuccess);
}
@@ -4980,9 +4943,7 @@
"for (const i, j = 1 in {}) {}",
"for (const i, j = void 0 in [1, 2, 3]) {}",
NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kError);
}
@@ -5009,9 +4970,7 @@
"for (const i, j = 1 of {}) {}",
"for (const i, j = void 0 of [1, 2, 3]) {}",
NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kError);
}
@@ -5026,9 +4985,7 @@
"for (var in {}) {}",
"for (const in {}) {}",
NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kError);
}
@@ -5043,9 +5000,7 @@
"for (var of [1, 2, 3]) {}",
"for (const of [1, 2, 3]) {}",
NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kError);
}
@@ -5059,10 +5014,7 @@
"for(x of 'foo' in {}) {}", "for(var x of 'foo' in {}) {}",
"for(let x of 'foo' in {}) {}", "for(const x of 'foo' in {}) {}", NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
- kAllowHarmonySloppyLet};
- RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kSuccess);
}
@@ -5073,10 +5025,7 @@
"for(let x of yield) {}", "for(const x of yield) {}",
NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
- kAllowHarmonySloppyLet};
- RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kSuccess);
}
@@ -5091,10 +5040,7 @@
"function* g() { for(let x of yield) {} }",
"function* g() { for(const x of yield) {} }", NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
- kAllowHarmonySloppyLet};
- RunParserSyncTest(context_data, data, kSuccess, nullptr, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kSuccess);
}
@@ -5112,10 +5058,7 @@
"for(x of { y = 23 }) {}", "for(var x of { y = 23 }) {}",
"for(let x of { y = 23 }) {}", "for(const x of { y = 23 }) {}", NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
- kAllowHarmonySloppyLet};
- RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kError);
}
@@ -5205,7 +5148,7 @@
"`foo${\r a}`",
"`foo${'a' in a}`",
NULL};
- RunParserSyncTest(context_data, data, kSuccess, NULL, 0, NULL, 0);
+ RunParserSyncTest(context_data, data, kSuccess);
}
@@ -5240,7 +5183,7 @@
"tag`foo${\r a}`",
"tag`foo${'a' in a}`",
NULL};
- RunParserSyncTest(context_data, data, kSuccess, NULL, 0, NULL, 0);
+ RunParserSyncTest(context_data, data, kSuccess);
}
@@ -5267,7 +5210,7 @@
NULL
};
- RunParserSyncTest(context_data, data, kSuccess, NULL, 0, NULL, 0);
+ RunParserSyncTest(context_data, data, kSuccess);
}
@@ -5301,7 +5244,7 @@
"`foo${fn(}`",
"`foo${1 if}`",
NULL};
- RunParserSyncTest(context_data, data, kError, NULL, 0, NULL, 0);
+ RunParserSyncTest(context_data, data, kError);
}
@@ -5321,7 +5264,7 @@
"`hello${1}\\x\n${2}`",
NULL};
- RunParserSyncTest(context_data, data, kError, NULL, 0, NULL, 0);
+ RunParserSyncTest(context_data, data, kError);
}
@@ -5396,13 +5339,12 @@
{nullptr, nullptr}};
const char* data[] = {"...a", "...arguments", "...eval", nullptr};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, data, kError, nullptr, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kError);
}
TEST(RestParametersEvalArguments) {
+ // clang-format off
const char* strict_context_data[][2] =
{{"'use strict';(function(",
"){ return;})(1, [], /regexp/, 'str',function(){});"},
@@ -5416,8 +5358,10 @@
"...eval",
"eval, ...args",
"...arguments",
- "arguments, ...args",
+ // See https://bugs.chromium.org/p/v8/issues/detail?id=4577
+ // "arguments, ...args",
NULL};
+ // clang-format on
// Fail in strict mode
RunParserSyncTest(strict_context_data, data, kError);
@@ -5484,7 +5428,7 @@
"var [...x,] = [1,2,3];", "var [...x, y] = [1,2,3];",
"var {...x} = [1,2,3];", "var { x } = {x: ...[1,2,3]}",
NULL};
- RunParserSyncTest(context_data, data, kError, NULL, 0, NULL, 0);
+ RunParserSyncTest(context_data, data, kError);
}
@@ -5494,28 +5438,12 @@
{"function f() {", "}"},
{"{", "}"},
{NULL, NULL}};
- const char* bad_data[] = {
- "let x = 1;",
- "for(let x = 1;;){}",
- "for(let x of []){}",
- "for(let x in []){}",
- "class C {}",
- "class C extends D {}",
- "(class {})",
- "(class extends D {})",
- "(class C {})",
- "(class C extends D {})",
- NULL};
- static const ParserFlag always_false_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, bad_data, kError, NULL, 0, NULL, 0,
- always_false_flags, arraysize(always_false_flags));
const char* good_data[] = {
"let = 1;",
"for(let = 1;;){}",
NULL};
- RunParserSyncTest(context_data, good_data, kSuccess, NULL, 0, NULL, 0,
- always_false_flags, arraysize(always_false_flags));
+ RunParserSyncTest(context_data, good_data, kSuccess);
}
@@ -5535,11 +5463,7 @@
"var name",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy,
- };
- RunParserSyncTest(context_data, error_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, error_data, kError);
const char* name_data[] = {
"1",
@@ -5550,8 +5474,7 @@
"{}",
NULL};
- RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, name_data, kSuccess);
}
@@ -5563,11 +5486,7 @@
"[1], a: 1",
NULL};
- static const ParserFlag always_flags[] = {
- kAllowHarmonySloppy,
- };
- RunParserSyncTest(context_data, error_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(context_data, error_data, kError);
}
@@ -5600,6 +5519,8 @@
"export { static } from 'm.js'",
"export { let } from 'm.js'",
"var a; export { a as b, a as c };",
+ "var a; export { a as await };",
+ "var a; export { a as enum };",
"import 'somemodule.js';",
"import { } from 'm.js';",
@@ -5725,6 +5646,8 @@
"import { y as yield } from 'm.js'",
"import { s as static } from 'm.js'",
"import { l as let } from 'm.js'",
+ "import { a as await } from 'm.js';",
+ "import { a as enum } from 'm.js';",
"import { x }, def from 'm.js';",
"import def, def2 from 'm.js';",
"import * as x, def from 'm.js';",
@@ -5757,6 +5680,179 @@
}
}
+TEST(ModuleTopLevelFunctionDecl) {
+ // clang-format off
+ const char* kErrorSources[] = {
+ "function f() {} function f() {}",
+ "var f; function f() {}",
+ "function f() {} var f;",
+ "function* f() {} function* f() {}",
+ "var f; function* f() {}",
+ "function* f() {} var f;",
+ "function f() {} function* f() {}",
+ "function* f() {} function f() {}",
+ };
+ // clang-format on
+
+ i::Isolate* isolate = CcTest::i_isolate();
+ i::Factory* factory = isolate->factory();
+
+ v8::HandleScope handles(CcTest::isolate());
+ v8::Local<v8::Context> context = v8::Context::New(CcTest::isolate());
+ v8::Context::Scope context_scope(context);
+
+ isolate->stack_guard()->SetStackLimit(i::GetCurrentStackPosition() -
+ 128 * 1024);
+
+ for (unsigned i = 0; i < arraysize(kErrorSources); ++i) {
+ i::Handle<i::String> source =
+ factory->NewStringFromAsciiChecked(kErrorSources[i]);
+
+ i::Handle<i::Script> script = factory->NewScript(source);
+ i::Zone zone(CcTest::i_isolate()->allocator());
+ i::ParseInfo info(&zone, script);
+ i::Parser parser(&info);
+ info.set_module();
+ CHECK(!parser.Parse(&info));
+ }
+}
+
+TEST(ModuleAwaitReserved) {
+ // clang-format off
+ const char* kErrorSources[] = {
+ "await;",
+ "await: ;",
+ "var await;",
+ "var [await] = [];",
+ "var { await } = {};",
+ "var { x: await } = {};",
+ "{ var await; }",
+ "let await;",
+ "let [await] = [];",
+ "let { await } = {};",
+ "let { x: await } = {};",
+ "{ let await; }",
+ "const await = null;",
+ "const [await] = [];",
+ "const { await } = {};",
+ "const { x: await } = {};",
+ "{ const await = null; }",
+ "function await() {}",
+ "function f(await) {}",
+ "function* await() {}",
+ "function* g(await) {}",
+ "(function await() {});",
+ "(function (await) {});",
+ "(function* await() {});",
+ "(function* (await) {});",
+ "(await) => {};",
+ "await => {};",
+ "class await {}",
+ "class C { constructor(await) {} }",
+ "class C { m(await) {} }",
+ "class C { static m(await) {} }",
+ "class C { *m(await) {} }",
+ "class C { static *m(await) {} }",
+ "(class await {})",
+ "(class { constructor(await) {} });",
+ "(class { m(await) {} });",
+ "(class { static m(await) {} });",
+ "(class { *m(await) {} });",
+ "(class { static *m(await) {} });",
+ "({ m(await) {} });",
+ "({ *m(await) {} });",
+ "({ set p(await) {} });",
+ "try {} catch (await) {}",
+ "try {} catch (await) {} finally {}",
+ NULL
+ };
+ // clang-format on
+ const char* context_data[][2] = {{"", ""}, {NULL, NULL}};
+
+ RunModuleParserSyncTest(context_data, kErrorSources, kError);
+}
+
+TEST(ModuleAwaitReservedPreParse) {
+ const char* context_data[][2] = {{"", ""}, {NULL, NULL}};
+ const char* error_data[] = {"function f() { var await = 0; }", NULL};
+
+ RunModuleParserSyncTest(context_data, error_data, kError);
+}
+
+TEST(ModuleAwaitPermitted) {
+ // clang-format off
+ const char* kValidSources[] = {
+ "({}).await;",
+ "({ await: null });",
+ "({ await() {} });",
+ "({ get await() {} });",
+ "({ set await(x) {} });",
+ "(class { await() {} });",
+ "(class { static await() {} });",
+ "(class { *await() {} });",
+ "(class { static *await() {} });",
+ NULL
+ };
+ // clang-format on
+ const char* context_data[][2] = {{"", ""}, {NULL, NULL}};
+
+ RunModuleParserSyncTest(context_data, kValidSources, kSuccess);
+}
+
+TEST(EnumReserved) {
+ // clang-format off
+ const char* kErrorSources[] = {
+ "enum;",
+ "enum: ;",
+ "var enum;",
+ "var [enum] = [];",
+ "var { enum } = {};",
+ "var { x: enum } = {};",
+ "{ var enum; }",
+ "let enum;",
+ "let [enum] = [];",
+ "let { enum } = {};",
+ "let { x: enum } = {};",
+ "{ let enum; }",
+ "const enum = null;",
+ "const [enum] = [];",
+ "const { enum } = {};",
+ "const { x: enum } = {};",
+ "{ const enum = null; }",
+ "function enum() {}",
+ "function f(enum) {}",
+ "function* enum() {}",
+ "function* g(enum) {}",
+ "(function enum() {});",
+ "(function (enum) {});",
+ "(function* enum() {});",
+ "(function* (enum) {});",
+ "(enum) => {};",
+ "enum => {};",
+ "class enum {}",
+ "class C { constructor(enum) {} }",
+ "class C { m(enum) {} }",
+ "class C { static m(enum) {} }",
+ "class C { *m(enum) {} }",
+ "class C { static *m(enum) {} }",
+ "(class enum {})",
+ "(class { constructor(enum) {} });",
+ "(class { m(enum) {} });",
+ "(class { static m(enum) {} });",
+ "(class { *m(enum) {} });",
+ "(class { static *m(enum) {} });",
+ "({ m(enum) {} });",
+ "({ *m(enum) {} });",
+ "({ set p(enum) {} });",
+ "try {} catch (enum) {}",
+ "try {} catch (enum) {} finally {}",
+ NULL
+ };
+ // clang-format on
+ const char* context_data[][2] = {{"", ""}, {NULL, NULL}};
+
+ RunModuleParserSyncTest(context_data, kErrorSources, kError);
+}
TEST(ModuleParsingInternals) {
i::Isolate* isolate = CcTest::i_isolate();
@@ -6213,9 +6309,7 @@
"[ a ]",
NULL};
// clang-format on
- static const ParserFlag always_flags[] = {kAllowHarmonySloppyLet};
- RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kError);
}
}
@@ -6684,6 +6778,9 @@
// Arrow function within generator has the same rules.
{"'use strict'; (function *g() { (", ") => {} });"},
{"(function *g() { (", ") => {} });"},
+ // And similarly for arrow functions in the parameter list.
+ {"'use strict'; (function *g(z = (", ") => {}) { });"},
+ {"(function *g(z = (", ") => {}) { });"},
{NULL, NULL}
};
@@ -6819,16 +6916,10 @@
NULL
};
- static const ParserFlag always_flags[] = {
- kAllowHarmonyNewTarget,
- kAllowHarmonySloppy,
- };
// clang-format on
- RunParserSyncTest(good_context_data, data, kSuccess, NULL, 0, always_flags,
- arraysize(always_flags));
- RunParserSyncTest(bad_context_data, data, kError, NULL, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(good_context_data, data, kSuccess);
+ RunParserSyncTest(bad_context_data, data, kError);
}
@@ -6848,9 +6939,7 @@
NULL
};
// clang-format on
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kSuccess);
}
@@ -6873,10 +6962,7 @@
};
// clang-format on
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
- kAllowHarmonySloppyLet};
- RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kSuccess);
}
@@ -6922,9 +7008,7 @@
"{ initializedBindingPattern } = { initializedBindingPattern: true }",
NULL};
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kError);
}
@@ -6952,10 +7036,7 @@
};
// clang-format on
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy,
- kAllowHarmonySloppyLet};
- RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
- arraysize(always_flags));
+ RunParserSyncTest(context_data, data, kSuccess);
// Some things should be rejected even in sloppy mode
// This addresses BUG(v8:4403).
@@ -6989,10 +7070,7 @@
};
// clang-format on
- static const ParserFlag fail_flags[] = {kAllowHarmonySloppy,
- kAllowHarmonySloppyLet};
- RunParserSyncTest(context_data, fail_data, kError, NULL, 0, fail_flags,
- arraysize(fail_flags));
+ RunParserSyncTest(context_data, fail_data, kError);
}
@@ -7092,13 +7170,9 @@
};
// clang-format on
- static const ParserFlag always_flags[] = {kAllowHarmonySloppy};
- RunParserSyncTest(sloppy_context_data, fail_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
- RunParserSyncTest(strict_context_data, fail_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
- RunModuleParserSyncTest(sloppy_context_data, fail_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(sloppy_context_data, fail_data, kError);
+ RunParserSyncTest(strict_context_data, fail_data, kError);
+ RunModuleParserSyncTest(sloppy_context_data, fail_data, kError);
// clang-format off
const char* let_data[] = {
@@ -7109,15 +7183,8 @@
};
// clang-format on
- RunParserSyncTest(sloppy_context_data, let_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
- RunParserSyncTest(strict_context_data, let_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
-
- static const ParserFlag sloppy_let_flags[] = {kAllowHarmonySloppy,
- kAllowHarmonySloppyLet};
- RunParserSyncTest(sloppy_context_data, let_data, kSuccess, NULL, 0,
- sloppy_let_flags, arraysize(sloppy_let_flags));
+ RunParserSyncTest(sloppy_context_data, let_data, kSuccess);
+ RunParserSyncTest(strict_context_data, let_data, kError);
// Non-errors in sloppy mode
const char* valid_data[] = {"(\\u0069mplements = 1);",
@@ -7142,12 +7209,9 @@
"var st\\u0061tic = 1;",
"var { st\\u0061tic } = {};",
NULL};
- RunParserSyncTest(sloppy_context_data, valid_data, kSuccess, NULL, 0,
- always_flags, arraysize(always_flags));
- RunParserSyncTest(strict_context_data, valid_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
- RunModuleParserSyncTest(strict_context_data, valid_data, kError, NULL, 0,
- always_flags, arraysize(always_flags));
+ RunParserSyncTest(sloppy_context_data, valid_data, kSuccess);
+ RunParserSyncTest(strict_context_data, valid_data, kError);
+ RunModuleParserSyncTest(strict_context_data, valid_data, kError);
}
@@ -7167,7 +7231,7 @@
};
// clang-format on
- RunParserSyncTest(context_data, error_data, kError, NULL, 0, NULL, 0);
+ RunParserSyncTest(context_data, error_data, kError);
}
@@ -7196,7 +7260,7 @@
};
// clang-format on
- RunParserSyncTest(context_data, error_data, kError, NULL, 0, NULL, 0);
+ RunParserSyncTest(context_data, error_data, kError);
}
@@ -7281,6 +7345,13 @@
"with ({}) label: function f() { };",
"if (true) label: function f() {}",
"if (true) {} else label: function f() {}",
+ "if (true) function* f() { }",
+ "label: function* f() { }",
+ // TODO(littledan, v8:4806): Ban duplicate generator declarations in
+ // a block, maybe by tracking whether a Variable is a generator declaration
+ // "{ function* f() {} function* f() {} }",
+ // "{ function f() {} function* f() {} }",
+ // "{ function* f() {} function f() {} }",
NULL
};
// Valid only in sloppy mode, with or without
@@ -7412,3 +7483,251 @@
RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
arraysize(always_flags));
}
+
+TEST(AsyncAwait) {
+ // clang-format off
+ const char* context_data[][2] = {
+ { "'use strict';", "" },
+ { "", "" },
+ { NULL, NULL }
+ };
+
+ const char* data[] = {
+ "var asyncFn = async function() { await 1; };",
+ "var asyncFn = async function withName() { await 1; };",
+ "var asyncFn = async () => await 'test';",
+ "var asyncFn = async x => await x + 'test';",
+ "async function asyncFn() { await 1; }",
+ "var O = { async method() { await 1; } }",
+ "var O = { async ['meth' + 'od']() { await 1; } }",
+ "var O = { async 'method'() { await 1; } }",
+ "var O = { async 0() { await 1; } }",
+ "async function await() {}",
+ NULL
+ };
+ // clang-format on
+
+ static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
+ RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
+ arraysize(always_flags));
+
+ // clang-format off
+ const char* async_body_context_data[][2] = {
+ { "async function f() {", "}" },
+ { "var f = async function() {", "}" },
+ { "var f = async() => {", "}" },
+ { "var O = { async method() {", "} }" },
+ { "'use strict'; async function f() {", "}" },
+ { "'use strict'; var f = async function() {", "}" },
+ { "'use strict'; var f = async() => {", "}" },
+ { "'use strict'; var O = { async method() {", "} }" },
+ { NULL, NULL }
+ };
+
+ const char* body_context_data[][2] = {
+ { "function f() {", "}" },
+ { "function* g() {", "}" },
+ { "var f = function() {", "}" },
+ { "var g = function*() {", "}" },
+ { "var O = { method() {", "} }" },
+ { "var O = { *method() {", "} }" },
+ { "var f = () => {", "}" },
+ { "'use strict'; function f() {", "}" },
+ { "'use strict'; function* g() {", "}" },
+ { "'use strict'; var f = function() {", "}" },
+ { "'use strict'; var g = function*() {", "}" },
+ { "'use strict'; var O = { method() {", "} }" },
+ { "'use strict'; var O = { *method() {", "} }" },
+ { "'use strict'; var f = () => {", "}" },
+ { NULL, NULL }
+ };
+
+ const char* body_data[] = {
+ "var async = 1; return async;",
+ "let async = 1; return async;",
+ "const async = 1; return async;",
+ "function async() {} return async();",
+ "var async = async => async; return async();",
+ "function foo() { var await = 1; return await; }",
+ "function foo(await) { return await; }",
+ "function* foo() { var await = 1; return await; }",
+ "function* foo(await) { return await; }",
+ "var f = (await) => await;",
+ "var f = () => { var await = 1; return await; }",
+ "var O = { method() { var await = 1; return await; } };",
+ "var O = { method(await) { return await; } };",
+ "var O = { *method() { var await = 1; return await; } };",
+ "var O = { *method(await) { return await; } };",
+
+ "(function await() {})",
+ NULL
+ };
+ // clang-format on
+
+ RunParserSyncTest(async_body_context_data, body_data, kSuccess, NULL, 0,
+ always_flags, arraysize(always_flags));
+ RunParserSyncTest(body_context_data, body_data, kSuccess, NULL, 0,
+ always_flags, arraysize(always_flags));
+}
+
+TEST(AsyncAwaitErrors) {
+ // clang-format off
+ const char* context_data[][2] = {
+ { "'use strict';", "" },
+ { "", "" },
+ { NULL, NULL }
+ };
+
+ const char* strict_context_data[][2] = {
+ { "'use strict';", "" },
+ { NULL, NULL }
+ };
+
+ const char* error_data[] = {
+ "var asyncFn = async function() { var await = 1; };",
+ "var asyncFn = async function() { var { await } = 1; };",
+ "var asyncFn = async function() { var [ await ] = 1; };",
+ "var asyncFn = async function await() {};",
+ "var asyncFn = async () => var await = 'test';",
+ "var asyncFn = async await => await + 'test';",
+ "var asyncFn = async function(await) {};",
+ "var asyncFn = async function() { return async (await) => {}; }",
+ "var asyncFn = async (await) => 'test';",
+ "var asyncFn = async x => { var await = 1; }",
+ "var asyncFn = async x => { var { await } = 1; }",
+ "var asyncFn = async x => { var [ await ] = 1; }",
+ "async function f(await) {}",
+ "async function f() { var await = 1; }",
+ "async function f() { var { await } = 1; }",
+ "async function f() { var [ await ] = 1; }",
+
+ "var O = { async method(a, a) {} }",
+ "var O = { async ['meth' + 'od'](a, a) {} }",
+ "var O = { async 'method'(a, a) {} }",
+ "var O = { async 0(a, a) {} }",
+
+ "async function f() { var O = { async [await](a, a) {} } }",
+
+ "var asyncFn = async function() { await; }",
+ "async function f() { await; }",
+ "var O = { async method() { await; } };",
+ "var f = async() => await;",
+ "var f = async() => { await; };",
+
+ "var asyncFn = async function*() {}",
+ "async function* f() {}",
+ "var O = { *async method() {} };",
+ "var O = { async *method() {} };",
+ "var O = { async method*() {} };",
+
+ "var asyncFn = async function(x = await 1) { return x; }",
+ "async function f(x = await 1) { return x; }",
+ "var f = async(x = await 1) => x;",
+ "var O = { async method(x = await 1) { return x; } };",
+
+ "var f = async(x = await) => 1;",
+
+ "class C { async constructor() {} }",
+ "class C {}; class C2 extends C { async constructor() {} }",
+ "class C { static async prototype() {} }",
+ "class C {}; class C2 extends C { static async prototype() {} }",
+
+ "var f = async() => ((async(x = await 1) => x)();",
+
+ "var asyncFn = async function() { function await() {} }",
+ "var asyncFn = async() => { function await() {} }",
+ "var O = { async method() { function await() {} } }",
+ "async function foo() { function await() {} }",
+
+ NULL
+ };
+
+ const char* strict_error_data[] = {
+ "var O = { async method(eval) {} }",
+ "var O = { async ['meth' + 'od'](eval) {} }",
+ "var O = { async 'method'(eval) {} }",
+ "var O = { async 0(eval) {} }",
+
+ "var O = { async method(arguments) {} }",
+ "var O = { async ['meth' + 'od'](arguments) {} }",
+ "var O = { async 'method'(arguments) {} }",
+ "var O = { async 0(arguments) {} }",
+
+ "var O = { async method(dupe, dupe) {} }",
+
+ // TODO(caitp): preparser needs to report duplicate parameter errors, too.
+ // "var f = async(dupe, dupe) => {}",
+
+ NULL
+ };
+ // clang-format on
+
+ static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
+ RunParserSyncTest(context_data, error_data, kError, NULL, 0, always_flags,
+ arraysize(always_flags));
+ RunParserSyncTest(strict_context_data, strict_error_data, kError, NULL, 0,
+ always_flags, arraysize(always_flags));
+}
+
+TEST(AsyncAwaitModule) {
+ // clang-format off
+ const char* context_data[][2] = {
+ { "", "" },
+ { NULL, NULL }
+ };
+
+ const char* data[] = {
+ "export default async function() { await 1; }",
+ "export default async function async() { await 1; }",
+ "export async function async() { await 1; }",
+ NULL
+ };
+ // clang-format on
+
+ static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
+ RunModuleParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
+ arraysize(always_flags), NULL, 0, false);
+}
+
+TEST(AsyncAwaitModuleErrors) {
+ // clang-format off
+ const char* context_data[][2] = {
+ { "", "" },
+ { NULL, NULL }
+ };
+
+ const char* error_data[] = {
+ "export default (async function await() {})",
+ "export default async function await() {}",
+ "export async function await() {}",
+ "export async function() {}",
+ "export async",
+ NULL
+ };
+ // clang-format on
+
+ static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
+ RunModuleParserSyncTest(context_data, error_data, kError, NULL, 0,
+ always_flags, arraysize(always_flags), NULL, 0,
+ false);
+}
+
+TEST(RestrictiveForInErrors) {
+ // clang-format off
+ const char* context_data[][2] = {
+ { "'use strict'", "" },
+ { "", "" },
+ { NULL, NULL }
+ };
+ const char* error_data[] = {
+ "for (var x = 0 in {});",
+ "for (const x = 0 in {});",
+ "for (let x = 0 in {});",
+ NULL
+ };
+ // clang-format on
+
+ static const ParserFlag always_flags[] = {kAllowHarmonyForIn};
+ RunParserSyncTest(context_data, error_data, kError, nullptr, 0, always_flags,
+ arraysize(always_flags));
+}
diff --git a/test/cctest/test-platform.cc b/test/cctest/test-platform.cc
index 6012fd4..48eda3d 100644
--- a/test/cctest/test-platform.cc
+++ b/test/cctest/test-platform.cc
@@ -25,9 +25,9 @@
#elif V8_HOST_ARCH_MIPS64
__asm__ __volatile__("sd $sp, %0" : "=g"(sp_addr));
#elif defined(__s390x__) || defined(_ARCH_S390X)
- __asm__ __volatile__("stg 15, %0" : "=g"(sp_addr));
+ __asm__ __volatile__("stg 15, %0" : "=m"(sp_addr));
#elif defined(__s390__) || defined(_ARCH_S390)
- __asm__ __volatile__("st 15, %0" : "=g"(sp_addr));
+ __asm__ __volatile__("st 15, %0" : "=m"(sp_addr));
#elif defined(__PPC64__) || defined(_ARCH_PPC64)
__asm__ __volatile__("std 1, %0" : "=g"(sp_addr));
#elif defined(__PPC__) || defined(_ARCH_PPC)
diff --git a/test/cctest/test-profile-generator.cc b/test/cctest/test-profile-generator.cc
index 48633f5..71c5ba8 100644
--- a/test/cctest/test-profile-generator.cc
+++ b/test/cctest/test-profile-generator.cc
@@ -698,12 +698,7 @@
" debugger;\n"
" startProfiling();\n"
"}\n"
- "function TryFinally() {\n"
- " try {\n"
- " Debugger();\n"
- " } finally { };\n"
- "}\n"
- "TryFinally();\n"
+ "Debugger();\n"
"stopProfiling();"));
script->Run(v8::Isolate::GetCurrent()->GetCurrentContext()).ToLocalChecked();
CHECK_EQ(1, iprofiler->GetProfilesCount());
@@ -715,15 +710,10 @@
// The tree should look like this:
// (root)
// ""
- // kTryFinallyStatement
- // kDebuggerStatement
+ // kDebuggerStatement
current = PickChild(current, "");
CHECK(const_cast<v8::CpuProfileNode*>(current));
- current = PickChild(current, "TryFinally");
- CHECK(const_cast<v8::CpuProfileNode*>(current));
- CHECK(!strcmp("TryFinallyStatement", current->GetBailoutReason()));
-
current = PickChild(current, "Debugger");
CHECK(const_cast<v8::CpuProfileNode*>(current));
CHECK(!strcmp("DebuggerStatement", current->GetBailoutReason()));
diff --git a/test/cctest/test-run-wasm-relocation-arm.cc b/test/cctest/test-run-wasm-relocation-arm.cc
index adfeb28..b2e6ec3 100644
--- a/test/cctest/test-run-wasm-relocation-arm.cc
+++ b/test/cctest/test-run-wasm-relocation-arm.cc
@@ -23,8 +23,7 @@
static int32_t DummyStaticFunction(Object* result) { return 1; }
-TEST(WasmRelocationArm) {
- CcTest::InitializeVM();
+TEST(WasmRelocationArmMemoryReference) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
v8::internal::byte buffer[4096];
@@ -77,4 +76,59 @@
#endif
}
+TEST(WasmRelocationArmMemorySizeReference) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+ v8::internal::byte buffer[4096];
+ DummyStaticFunction(NULL);
+ int32_t size = 512;
+ Label fail;
+
+ Assembler assm(isolate, buffer, sizeof buffer);
+
+ __ mov(r0, Operand(size, RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+ __ cmp(r0, Operand(size, RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+ __ b(ne, &fail);
+ __ mov(pc, Operand(lr));
+ __ bind(&fail);
+ __ mov(r0, Operand(0xdeadbeef));
+ __ mov(pc, Operand(lr));
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+ CSignature0<int32_t> csig;
+ CodeRunner<int32_t> runnable(isolate, code, &csig);
+ int32_t ret_value = runnable.Call();
+ CHECK_NE(ret_value, 0xdeadbeef);
+
+#ifdef DEBUG
+ OFStream os(stdout);
+ code->Print(os);
+ ::printf("f() = %d\n\n", ret_value);
+#endif
+ size_t diff = 512;
+
+ int mode_mask = (1 << RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+ for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
+ RelocInfo::Mode mode = it.rinfo()->rmode();
+ if (RelocInfo::IsWasmMemorySizeReference(mode)) {
+ it.rinfo()->update_wasm_memory_reference(
+ reinterpret_cast<Address>(1234), reinterpret_cast<Address>(1234),
+ it.rinfo()->wasm_memory_size_reference(),
+ it.rinfo()->wasm_memory_size_reference() + diff, SKIP_ICACHE_FLUSH);
+ }
+ }
+
+ ret_value = runnable.Call();
+ CHECK_NE(ret_value, 0xdeadbeef);
+
+#ifdef DEBUG
+ code->Print(os);
+ ::printf("f() = %d\n\n", ret_value);
+#endif
+}
#undef __
diff --git a/test/cctest/test-run-wasm-relocation-arm64.cc b/test/cctest/test-run-wasm-relocation-arm64.cc
index 48f9e85..3b49f00 100644
--- a/test/cctest/test-run-wasm-relocation-arm64.cc
+++ b/test/cctest/test-run-wasm-relocation-arm64.cc
@@ -24,8 +24,7 @@
static int64_t DummyStaticFunction(Object* result) { return 1; }
-TEST(WasmRelocationArm64) {
- CcTest::InitializeVM();
+TEST(WasmRelocationArm64MemoryReference) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
v8::internal::byte buffer[4096];
@@ -51,7 +50,7 @@
#ifdef DEBUG
OFStream os(stdout);
code->Print(os);
- ::printf("f() = %ld\n\n", ret_value);
+ ::printf("f() = %" PRIx64 "\n\n", ret_value);
#endif
size_t offset = 1234;
@@ -75,7 +74,64 @@
#ifdef DEBUG
code->Print(os);
- ::printf("f() = %ld\n\n", ret_value);
+ ::printf("f() = %" PRIx64 "\n\n", ret_value);
+#endif
+}
+
+TEST(WasmRelocationArm64MemorySizeReference) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+ v8::internal::byte buffer[4096];
+ DummyStaticFunction(NULL);
+ Immediate size = Immediate(512, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+ Label fail;
+
+ MacroAssembler masm(isolate, buffer, sizeof buffer,
+ v8::internal::CodeObjectRequired::kYes);
+
+ __ Mov(x0, size);
+ __ Cmp(x0, size);
+ __ B(ne, &fail);
+ __ Ret();
+ __ Bind(&fail);
+ __ Mov(x0, Immediate(0xdeadbeef));
+ __ Ret();
+
+ CodeDesc desc;
+ masm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+ CSignature0<int64_t> csig;
+ CodeRunner<int64_t> runnable(isolate, code, &csig);
+ int64_t ret_value = runnable.Call();
+ CHECK_NE(ret_value, 0xdeadbeef);
+
+#ifdef DEBUG
+ OFStream os(stdout);
+ code->Print(os);
+ ::printf("f() = %" PRIx64 "\n\n", ret_value);
+#endif
+ int32_t diff = 512;
+
+ int mode_mask = (1 << RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+ for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
+ RelocInfo::Mode mode = it.rinfo()->rmode();
+ if (RelocInfo::IsWasmMemorySizeReference(mode)) {
+ it.rinfo()->update_wasm_memory_reference(
+ reinterpret_cast<Address>(0x1234), reinterpret_cast<Address>(0x1234),
+ it.rinfo()->wasm_memory_size_reference(),
+ it.rinfo()->wasm_memory_size_reference() + diff, SKIP_ICACHE_FLUSH);
+ }
+ }
+
+ ret_value = runnable.Call();
+ CHECK_NE(ret_value, 0xdeadbeef);
+
+#ifdef DEBUG
+ code->Print(os);
+ ::printf("f() = %" PRIx64 "\n\n", ret_value);
#endif
}
diff --git a/test/cctest/test-run-wasm-relocation-ia32.cc b/test/cctest/test-run-wasm-relocation-ia32.cc
index 135b522..305d008 100644
--- a/test/cctest/test-run-wasm-relocation-ia32.cc
+++ b/test/cctest/test-run-wasm-relocation-ia32.cc
@@ -23,8 +23,7 @@
static int32_t DummyStaticFunction(Object* result) { return 1; }
-TEST(WasmRelocationIa32) {
- CcTest::InitializeVM();
+TEST(WasmRelocationIa32MemoryReference) {
Isolate* isolate = CcTest::i_isolate();
Zone zone(isolate->allocator());
HandleScope scope(isolate);
@@ -78,7 +77,6 @@
CHECK_EQ(ret_value, imm + offset);
#ifdef OBJECT_PRINT
- // OFStream os(stdout);
code->Print(os);
begin = code->instruction_start();
end = begin + code->instruction_size();
@@ -86,4 +84,67 @@
#endif
}
+TEST(WasmRelocationIa32MemorySizeReference) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ Zone zone(isolate->allocator());
+ HandleScope scope(isolate);
+ v8::internal::byte buffer[4096];
+ Assembler assm(isolate, buffer, sizeof buffer);
+ DummyStaticFunction(NULL);
+ int32_t size = 80;
+ Label fail;
+
+ __ mov(eax, Immediate(reinterpret_cast<Address>(size),
+ RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+ __ cmp(eax, Immediate(reinterpret_cast<Address>(size),
+ RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+ __ j(not_equal, &fail);
+ __ ret(0);
+ __ bind(&fail);
+ __ mov(eax, 0xdeadbeef);
+ __ ret(0);
+
+ CSignature0<int32_t> csig;
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+ USE(code);
+
+ CodeRunner<int32_t> runnable(isolate, code, &csig);
+ int32_t ret_value = runnable.Call();
+ CHECK_NE(ret_value, 0xdeadbeef);
+
+#ifdef OBJECT_PRINT
+ OFStream os(stdout);
+ code->Print(os);
+ byte* begin = code->instruction_start();
+ byte* end = begin + code->instruction_size();
+ disasm::Disassembler::Disassemble(stdout, begin, end);
+#endif
+
+ size_t offset = 10;
+
+ int mode_mask = (1 << RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+ for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
+ RelocInfo::Mode mode = it.rinfo()->rmode();
+ if (RelocInfo::IsWasmMemorySizeReference(mode)) {
+ it.rinfo()->update_wasm_memory_reference(
+ reinterpret_cast<Address>(1234), reinterpret_cast<Address>(1234),
+ it.rinfo()->wasm_memory_size_reference(),
+ it.rinfo()->wasm_memory_size_reference() + offset, SKIP_ICACHE_FLUSH);
+ }
+ }
+
+ ret_value = runnable.Call();
+ CHECK_NE(ret_value, 0xdeadbeef);
+
+#ifdef OBJECT_PRINT
+ code->Print(os);
+ begin = code->instruction_start();
+ end = begin + code->instruction_size();
+ disasm::Disassembler::Disassemble(stdout, begin, end);
+#endif
+}
#undef __
diff --git a/test/cctest/test-run-wasm-relocation-x64.cc b/test/cctest/test-run-wasm-relocation-x64.cc
index f1b6d96..11fa451 100644
--- a/test/cctest/test-run-wasm-relocation-x64.cc
+++ b/test/cctest/test-run-wasm-relocation-x64.cc
@@ -21,8 +21,8 @@
#define __ assm.
static int32_t DummyStaticFunction(Object* result) { return 1; }
-TEST(WasmRelocationX64movq64) {
- CcTest::InitializeVM();
+
+TEST(WasmRelocationX64MemoryReference) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
v8::internal::byte buffer[4096];
@@ -80,4 +80,63 @@
#endif
}
+TEST(WasmRelocationX64WasmMemorySizeReference) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+ v8::internal::byte buffer[4096];
+ Assembler assm(isolate, buffer, sizeof buffer);
+ DummyStaticFunction(NULL);
+ int32_t size = 512;
+ Label fail;
+
+ __ movl(rax, Immediate(size, RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+ __ cmpl(rax, Immediate(size, RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+ __ j(not_equal, &fail);
+ __ ret(0);
+ __ bind(&fail);
+ __ movl(rax, Immediate(0xdeadbeef));
+ __ ret(0);
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+ USE(code);
+
+ CSignature0<int64_t> csig;
+ CodeRunner<int64_t> runnable(isolate, code, &csig);
+ int64_t ret_value = runnable.Call();
+ CHECK_NE(ret_value, 0xdeadbeef);
+
+#ifdef OBJECT_PRINT
+ OFStream os(stdout);
+ code->Print(os);
+ byte* begin = code->instruction_start();
+ byte* end = begin + code->instruction_size();
+ disasm::Disassembler::Disassemble(stdout, begin, end);
+#endif
+ int32_t diff = 512;
+
+ int mode_mask = (1 << RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+ for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
+ RelocInfo::Mode mode = it.rinfo()->rmode();
+ if (RelocInfo::IsWasmMemorySizeReference(mode)) {
+ it.rinfo()->update_wasm_memory_reference(
+ reinterpret_cast<Address>(1234), reinterpret_cast<Address>(1234),
+ it.rinfo()->wasm_memory_size_reference(),
+ it.rinfo()->wasm_memory_size_reference() + diff, SKIP_ICACHE_FLUSH);
+ }
+ }
+
+ ret_value = runnable.Call();
+ CHECK_NE(ret_value, 0xdeadbeef);
+
+#ifdef OBJECT_PRINT
+ code->Print(os);
+ begin = code->instruction_start();
+ end = begin + code->instruction_size();
+ disasm::Disassembler::Disassemble(stdout, begin, end);
+#endif
+}
#undef __
diff --git a/test/cctest/test-run-wasm-relocation-x87.cc b/test/cctest/test-run-wasm-relocation-x87.cc
index 6cbd065..2156e96 100644
--- a/test/cctest/test-run-wasm-relocation-x87.cc
+++ b/test/cctest/test-run-wasm-relocation-x87.cc
@@ -23,8 +23,7 @@
static int32_t DummyStaticFunction(Object* result) { return 1; }
-TEST(WasmRelocationIa32) {
- CcTest::InitializeVM();
+TEST(WasmRelocationX87MemoryReference) {
Isolate* isolate = CcTest::i_isolate();
Zone zone(isolate->allocator());
HandleScope scope(isolate);
@@ -78,7 +77,6 @@
CHECK_EQ(ret_value, imm + offset);
#ifdef OBJECT_PRINT
- // OFStream os(stdout);
code->Print(os);
begin = code->instruction_start();
end = begin + code->instruction_size();
@@ -86,4 +84,67 @@
#endif
}
+TEST(WasmRelocationX87MemorySizeReference) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ Zone zone(isolate->allocator());
+ HandleScope scope(isolate);
+ v8::internal::byte buffer[4096];
+ Assembler assm(isolate, buffer, sizeof buffer);
+ DummyStaticFunction(NULL);
+ int32_t size = 80;
+ Label fail;
+
+ __ mov(eax, Immediate(reinterpret_cast<Address>(size),
+ RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+ __ cmp(eax, Immediate(reinterpret_cast<Address>(size),
+ RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+ __ j(not_equal, &fail);
+ __ ret(0);
+ __ bind(&fail);
+ __ mov(eax, 0xdeadbeef);
+ __ ret(0);
+
+ CSignature0<int32_t> csig;
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+ USE(code);
+
+ CodeRunner<int32_t> runnable(isolate, code, &csig);
+ int32_t ret_value = runnable.Call();
+ CHECK_NE(ret_value, 0xdeadbeef);
+
+#ifdef OBJECT_PRINT
+ OFStream os(stdout);
+ code->Print(os);
+ byte* begin = code->instruction_start();
+ byte* end = begin + code->instruction_size();
+ disasm::Disassembler::Disassemble(stdout, begin, end);
+#endif
+
+ size_t offset = 10;
+
+ int mode_mask = (1 << RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
+ for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
+ RelocInfo::Mode mode = it.rinfo()->rmode();
+ if (RelocInfo::IsWasmMemorySizeReference(mode)) {
+ it.rinfo()->update_wasm_memory_reference(
+ reinterpret_cast<Address>(1234), reinterpret_cast<Address>(1234),
+ it.rinfo()->wasm_memory_size_reference(),
+ it.rinfo()->wasm_memory_size_reference() + offset, SKIP_ICACHE_FLUSH);
+ }
+ }
+
+ ret_value = runnable.Call();
+ CHECK_NE(ret_value, 0xdeadbeef);
+
+#ifdef OBJECT_PRINT
+ code->Print(os);
+ begin = code->instruction_start();
+ end = begin + code->instruction_size();
+ disasm::Disassembler::Disassemble(stdout, begin, end);
+#endif
+}
#undef __
diff --git a/test/cctest/test-typing-reset.cc b/test/cctest/test-typing-reset.cc
deleted file mode 100644
index 4e9413a..0000000
--- a/test/cctest/test-typing-reset.cc
+++ /dev/null
@@ -1,298 +0,0 @@
-// Copyright 2015 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 <stdlib.h>
-
-#include "src/v8.h"
-
-#include "src/ast/ast.h"
-#include "src/ast/ast-expression-visitor.h"
-#include "src/ast/scopes.h"
-#include "src/parsing/parser.h"
-#include "src/parsing/rewriter.h"
-#include "src/typing-reset.h"
-#include "test/cctest/cctest.h"
-#include "test/cctest/compiler/function-tester.h"
-#include "test/cctest/expression-type-collector.h"
-#include "test/cctest/expression-type-collector-macros.h"
-
-#define INT32_TYPE Bounds(Type::Signed32(), Type::Signed32())
-
-using namespace v8::internal;
-
-namespace {
-
-class TypeSetter : public AstExpressionVisitor {
- public:
- TypeSetter(Isolate* isolate, FunctionLiteral* root)
- : AstExpressionVisitor(isolate, root) {}
-
- protected:
- void VisitExpression(Expression* expression) {
- expression->set_bounds(INT32_TYPE);
- }
-};
-
-
-void CheckAllSame(ZoneVector<ExpressionTypeEntry>& types,
- Bounds expected_type) {
- CHECK_TYPES_BEGIN {
- // function logSum
- CHECK_EXPR(FunctionLiteral, expected_type) {
- CHECK_EXPR(FunctionLiteral, expected_type) {
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(start, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(start, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- }
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(end, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(end, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- }
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(sum, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(p, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(q, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- // for (p = start << 3, q = end << 3;
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(p, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(start, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- }
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(q, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(end, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- }
- }
- // (p|0) < (q|0);
- CHECK_EXPR(CompareOperation, expected_type) {
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(p, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(q, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- }
- // p = (p + 8)|0) {\n"
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(p, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(p, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- CHECK_EXPR(Literal, expected_type);
- }
- }
- // sum = sum + +log(values[p>>3]);
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(sum, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(sum, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_EXPR(Call, expected_type) {
- CHECK_VAR(log, expected_type);
- CHECK_EXPR(Property, expected_type) {
- CHECK_VAR(values, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(p, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- }
- }
- CHECK_EXPR(Literal, expected_type);
- }
- }
- }
- // return +sum;
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(sum, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- }
- // function geometricMean
- CHECK_EXPR(FunctionLiteral, expected_type) {
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(start, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(start, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- }
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(end, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(end, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- }
- // return +exp(+logSum(start, end) / +((end - start)|0));
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_EXPR(Call, expected_type) {
- CHECK_VAR(exp, expected_type);
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_EXPR(Call, expected_type) {
- CHECK_VAR(logSum, expected_type);
- CHECK_VAR(start, expected_type);
- CHECK_VAR(end, expected_type);
- }
- CHECK_EXPR(Literal, expected_type);
- }
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_EXPR(BinaryOperation, expected_type) {
- CHECK_VAR(end, expected_type);
- CHECK_VAR(start, expected_type);
- }
- CHECK_EXPR(Literal, expected_type);
- }
- CHECK_EXPR(Literal, expected_type);
- }
- }
- }
- CHECK_EXPR(Literal, expected_type);
- }
- }
- // "use asm";
- CHECK_EXPR(Literal, expected_type);
- // var exp = stdlib.Math.exp;
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(exp, expected_type);
- CHECK_EXPR(Property, expected_type) {
- CHECK_EXPR(Property, expected_type) {
- CHECK_VAR(stdlib, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- CHECK_EXPR(Literal, expected_type);
- }
- }
- // var log = stdlib.Math.log;
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(log, expected_type);
- CHECK_EXPR(Property, expected_type) {
- CHECK_EXPR(Property, expected_type) {
- CHECK_VAR(stdlib, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- CHECK_EXPR(Literal, expected_type);
- }
- }
- // var values = new stdlib.Float64Array(buffer);
- CHECK_EXPR(Assignment, expected_type) {
- CHECK_VAR(values, expected_type);
- CHECK_EXPR(CallNew, expected_type) {
- CHECK_EXPR(Property, expected_type) {
- CHECK_VAR(stdlib, expected_type);
- CHECK_EXPR(Literal, expected_type);
- }
- CHECK_VAR(buffer, expected_type);
- }
- }
- // return { geometricMean: geometricMean };
- CHECK_EXPR(ObjectLiteral, expected_type) {
- CHECK_VAR(geometricMean, expected_type);
- }
- }
- }
- CHECK_TYPES_END
-}
-
-} // namespace
-
-
-TEST(ResetTypingInfo) {
- const char test_function[] =
- "function GeometricMean(stdlib, foreign, buffer) {\n"
- " \"use asm\";\n"
- "\n"
- " var exp = stdlib.Math.exp;\n"
- " var log = stdlib.Math.log;\n"
- " var values = new stdlib.Float64Array(buffer);\n"
- "\n"
- " function logSum(start, end) {\n"
- " start = start|0;\n"
- " end = end|0;\n"
- "\n"
- " var sum = 0.0, p = 0, q = 0;\n"
- "\n"
- " // asm.js forces byte addressing of the heap by requiring shifting "
- "by 3\n"
- " for (p = start << 3, q = end << 3; (p|0) < (q|0); p = (p + 8)|0) {\n"
- " sum = sum + +log(values[p>>3]);\n"
- " }\n"
- "\n"
- " return +sum;\n"
- " }\n"
- "\n"
- " function geometricMean(start, end) {\n"
- " start = start|0;\n"
- " end = end|0;\n"
- "\n"
- " return +exp(+logSum(start, end) / +((end - start)|0));\n"
- " }\n"
- "\n"
- " return { geometricMean: geometricMean };\n"
- "}\n";
-
- v8::V8::Initialize();
- HandleAndZoneScope handles;
-
- i::Isolate* isolate = CcTest::i_isolate();
- i::Factory* factory = isolate->factory();
-
- i::Handle<i::String> source_code =
- factory->NewStringFromUtf8(i::CStrVector(test_function))
- .ToHandleChecked();
-
- i::Handle<i::Script> script = factory->NewScript(source_code);
-
- i::ParseInfo info(handles.main_zone(), script);
- i::Parser parser(&info);
- parser.set_allow_harmony_sloppy(true);
- info.set_global();
- info.set_lazy(false);
- info.set_allow_lazy_parsing(false);
- info.set_toplevel(true);
-
- CHECK(i::Compiler::ParseAndAnalyze(&info));
- FunctionLiteral* root =
- info.scope()->declarations()->at(0)->AsFunctionDeclaration()->fun();
-
- // Core of the test.
- ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
- ExpressionTypeCollector(isolate, root, &types).Run();
- CheckAllSame(types, Bounds::Unbounded());
-
- TypeSetter(isolate, root).Run();
-
- ExpressionTypeCollector(isolate, root, &types).Run();
- CheckAllSame(types, INT32_TYPE);
-
- TypingReseter(isolate, root).Run();
-
- ExpressionTypeCollector(isolate, root, &types).Run();
- CheckAllSame(types, Bounds::Unbounded());
-}
diff --git a/test/cctest/test-unboxed-doubles.cc b/test/cctest/test-unboxed-doubles.cc
index 7fc9b5b..39f8fbf 100644
--- a/test/cctest/test-unboxed-doubles.cc
+++ b/test/cctest/test-unboxed-doubles.cc
@@ -1504,10 +1504,12 @@
CHECK_EQ(boom_value, obj->RawFastDoublePropertyAt(double_field_index));
}
-
-enum WriteBarrierKind { OLD_TO_OLD_WRITE_BARRIER, OLD_TO_NEW_WRITE_BARRIER };
+enum OldToWriteBarrierKind {
+ OLD_TO_OLD_WRITE_BARRIER,
+ OLD_TO_NEW_WRITE_BARRIER
+};
static void TestWriteBarrierObjectShiftFieldsRight(
- WriteBarrierKind write_barrier_kind) {
+ OldToWriteBarrierKind write_barrier_kind) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
v8::HandleScope scope(CcTest::isolate());
diff --git a/test/cctest/test-weakmaps.cc b/test/cctest/test-weakmaps.cc
index 781ad1f..829f320 100644
--- a/test/cctest/test-weakmaps.cc
+++ b/test/cctest/test-weakmaps.cc
@@ -52,8 +52,7 @@
}
static int NumberOfWeakCalls = 0;
-static void WeakPointerCallback(
- const v8::WeakCallbackData<v8::Value, void>& data) {
+static void WeakPointerCallback(const v8::WeakCallbackInfo<void>& data) {
std::pair<v8::Persistent<v8::Value>*, int>* p =
reinterpret_cast<std::pair<v8::Persistent<v8::Value>*, int>*>(
data.GetParameter());
@@ -107,20 +106,12 @@
{
HandleScope scope(isolate);
std::pair<Handle<Object>*, int> handle_and_id(&key, 1234);
- GlobalHandles::MakeWeak(key.location(),
- reinterpret_cast<void*>(&handle_and_id),
- &WeakPointerCallback);
+ GlobalHandles::MakeWeak(
+ key.location(), reinterpret_cast<void*>(&handle_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
}
CHECK(global_handles->IsWeak(key.location()));
- // Force a full GC.
- // Perform two consecutive GCs because the first one will only clear
- // weak references whereas the second one will also clear weak maps.
- heap->CollectAllGarbage(false);
- CHECK_EQ(1, NumberOfWeakCalls);
- CHECK_EQ(2, ObjectHashTable::cast(weakmap->table())->NumberOfElements());
- CHECK_EQ(
- 0, ObjectHashTable::cast(weakmap->table())->NumberOfDeletedElements());
heap->CollectAllGarbage(false);
CHECK_EQ(1, NumberOfWeakCalls);
CHECK_EQ(0, ObjectHashTable::cast(weakmap->table())->NumberOfElements());
diff --git a/test/cctest/test-weaksets.cc b/test/cctest/test-weaksets.cc
index 643bb48..53a5913 100644
--- a/test/cctest/test-weaksets.cc
+++ b/test/cctest/test-weaksets.cc
@@ -55,8 +55,7 @@
}
static int NumberOfWeakCalls = 0;
-static void WeakPointerCallback(
- const v8::WeakCallbackData<v8::Value, void>& data) {
+static void WeakPointerCallback(const v8::WeakCallbackInfo<void>& data) {
std::pair<v8::Persistent<v8::Value>*, int>* p =
reinterpret_cast<std::pair<v8::Persistent<v8::Value>*, int>*>(
data.GetParameter());
@@ -106,20 +105,12 @@
{
HandleScope scope(isolate);
std::pair<Handle<Object>*, int> handle_and_id(&key, 1234);
- GlobalHandles::MakeWeak(key.location(),
- reinterpret_cast<void*>(&handle_and_id),
- &WeakPointerCallback);
+ GlobalHandles::MakeWeak(
+ key.location(), reinterpret_cast<void*>(&handle_and_id),
+ &WeakPointerCallback, v8::WeakCallbackType::kParameter);
}
CHECK(global_handles->IsWeak(key.location()));
- // Force a full GC.
- // Perform two consecutive GCs because the first one will only clear
- // weak references whereas the second one will also clear weak sets.
- heap->CollectAllGarbage(false);
- CHECK_EQ(1, NumberOfWeakCalls);
- CHECK_EQ(1, ObjectHashTable::cast(weakset->table())->NumberOfElements());
- CHECK_EQ(
- 0, ObjectHashTable::cast(weakset->table())->NumberOfDeletedElements());
heap->CollectAllGarbage(false);
CHECK_EQ(1, NumberOfWeakCalls);
CHECK_EQ(0, ObjectHashTable::cast(weakset->table())->NumberOfElements());
diff --git a/test/cctest/trace-extension.cc b/test/cctest/trace-extension.cc
index 77a29e9..6eb81b2 100644
--- a/test/cctest/trace-extension.cc
+++ b/test/cctest/trace-extension.cc
@@ -27,7 +27,7 @@
#include "test/cctest/trace-extension.h"
-#include "src/profiler/sampler.h"
+#include "src/profiler/tick-sample.h"
#include "src/vm-state-inl.h"
#include "test/cctest/cctest.h"
diff --git a/test/cctest/wasm/test-run-wasm-64.cc b/test/cctest/wasm/test-run-wasm-64.cc
index 784f21a..333183a 100644
--- a/test/cctest/wasm/test-run-wasm-64.cc
+++ b/test/cctest/wasm/test-run-wasm-64.cc
@@ -24,20 +24,14 @@
#define asu64(x) static_cast<uint64_t>(x)
-#define B2(a, b) kExprBlock, 2, a, b
-#define B1(a) kExprBlock, 1, a
+#define B2(a, b) kExprBlock, a, b, kExprEnd
+#define B1(a) kExprBlock, a, kExprEnd
// Can't bridge macro land with nested macros.
-#if V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_X87
-#define MIPS_OR_X87 true
+#if V8_TARGET_ARCH_MIPS
+#define MIPS true
#else
-#define MIPS_OR_X87 false
-#endif
-
-#if V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_X87 || V8_TARGET_ARCH_ARM
-#define MIPS_OR_ARM_OR_X87 true
-#else
-#define MIPS_OR_ARM_OR_X87 false
+#define MIPS false
#endif
#define FOREACH_I64_OPERATOR(V) \
@@ -47,9 +41,9 @@
V(I64Return, true) \
V(I64Param, true) \
V(I64LoadStore, true) \
- V(I64Add, !MIPS_OR_X87) \
- V(I64Sub, !MIPS_OR_X87) \
- V(I64Mul, !MIPS_OR_X87) \
+ V(I64Add, true) \
+ V(I64Sub, true) \
+ V(I64Mul, !MIPS) \
V(I64DivS, true) \
V(I64DivU, true) \
V(I64RemS, true) \
@@ -57,9 +51,9 @@
V(I64And, true) \
V(I64Ior, true) \
V(I64Xor, true) \
- V(I64Shl, !MIPS_OR_X87) \
- V(I64ShrU, !MIPS_OR_X87) \
- V(I64ShrS, !MIPS_OR_X87) \
+ V(I64Shl, true) \
+ V(I64ShrU, true) \
+ V(I64ShrS, true) \
V(I64Eq, true) \
V(I64Ne, true) \
V(I64LtS, true) \
@@ -72,7 +66,7 @@
V(I64GeU, true) \
V(I64Ctz, true) \
V(I64Clz, true) \
- V(I64Popcnt, !MIPS_OR_X87) \
+ V(I64Popcnt, true) \
V(I32ConvertI64, true) \
V(I64SConvertF32, true) \
V(I64SConvertF64, true) \
@@ -96,7 +90,7 @@
#define REQUIRE(name) \
if (!WASM_64 && !kSupported_##name) return
-TEST(Run_Wasm_I64Const) {
+WASM_EXEC_TEST(I64Const) {
REQUIRE(I64Const);
WasmRunner<int64_t> r;
const int64_t kExpectedValue = 0x1122334455667788LL;
@@ -105,7 +99,7 @@
CHECK_EQ(kExpectedValue, r.Call());
}
-TEST(Run_Wasm_I64Const_many) {
+WASM_EXEC_TEST(I64Const_many) {
REQUIRE(I64Const);
int cntr = 0;
FOR_INT32_INPUTS(i) {
@@ -118,19 +112,16 @@
}
}
-TEST(Run_Wasm_Return_I64) {
+WASM_EXEC_TEST(Return_I64) {
REQUIRE(I64Return);
WasmRunner<int64_t> r(MachineType::Int64());
- BUILD(r, WASM_RETURN(WASM_GET_LOCAL(0)));
+ BUILD(r, WASM_RETURN1(WASM_GET_LOCAL(0)));
FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
}
-// todo(ahaas): I added a list of missing instructions here to make merging
-// easier when I do them one by one.
-// kExprI64Add:
-TEST(Run_WasmI64Add) {
+WASM_EXEC_TEST(I64Add) {
REQUIRE(I64Add);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -138,8 +129,8 @@
FOR_INT64_INPUTS(j) { CHECK_EQ(*i + *j, r.Call(*i, *j)); }
}
}
-// kExprI64Sub:
-TEST(Run_Wasm_I64Sub) {
+
+WASM_EXEC_TEST(I64Sub) {
REQUIRE(I64Sub);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -147,10 +138,8 @@
FOR_INT64_INPUTS(j) { CHECK_EQ(*i - *j, r.Call(*i, *j)); }
}
}
-// kExprI64Mul:
-// kExprI64DivS:
-TEST(Run_WasmI64DivS) {
+WASM_EXEC_TEST(I64DivS) {
REQUIRE(I64DivS);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -167,7 +156,7 @@
}
}
-TEST(Run_WasmI64DivS_Trap) {
+WASM_EXEC_TEST(I64DivS_Trap) {
REQUIRE(I64DivS);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -178,7 +167,7 @@
CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(0)));
}
-TEST(Run_WasmI64DivS_Byzero_Const) {
+WASM_EXEC_TEST(I64DivS_Byzero_Const) {
REQUIRE(I64DivS);
for (int8_t denom = -2; denom < 8; denom++) {
WasmRunner<int64_t> r(MachineType::Int64());
@@ -192,9 +181,8 @@
}
}
}
-// kExprI64DivU:
-TEST(Run_WasmI64DivU) {
+WASM_EXEC_TEST(I64DivU) {
REQUIRE(I64DivU);
WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -209,7 +197,7 @@
}
}
-TEST(Run_WasmI64DivU_Trap) {
+WASM_EXEC_TEST(I64DivU_Trap) {
REQUIRE(I64DivU);
WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -219,7 +207,7 @@
CHECK_TRAP64(r.Call(std::numeric_limits<uint64_t>::max(), asu64(0)));
}
-TEST(Run_WasmI64DivU_Byzero_Const) {
+WASM_EXEC_TEST(I64DivU_Byzero_Const) {
REQUIRE(I64DivU);
for (uint64_t denom = 0xfffffffffffffffe; denom < 8; denom++) {
WasmRunner<uint64_t> r(MachineType::Uint64());
@@ -234,8 +222,8 @@
}
}
}
-// kExprI64RemS:
-TEST(Run_WasmI64RemS) {
+
+WASM_EXEC_TEST(I64RemS) {
REQUIRE(I64RemS);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -250,7 +238,7 @@
}
}
-TEST(Run_WasmI64RemS_Trap) {
+WASM_EXEC_TEST(I64RemS_Trap) {
REQUIRE(I64RemS);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -261,8 +249,7 @@
CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), asi64(0)));
}
-// kExprI64RemU:
-TEST(Run_WasmI64RemU) {
+WASM_EXEC_TEST(I64RemU) {
REQUIRE(I64RemU);
WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -277,7 +264,7 @@
}
}
-TEST(Run_Wasm_I64RemU_Trap) {
+WASM_EXEC_TEST(I64RemU_Trap) {
REQUIRE(I64RemU);
WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -287,8 +274,7 @@
CHECK_TRAP64(r.Call(std::numeric_limits<uint64_t>::max(), asu64(0)));
}
-// kExprI64And:
-TEST(Run_Wasm_I64And) {
+WASM_EXEC_TEST(I64And) {
REQUIRE(I64And);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -296,8 +282,8 @@
FOR_INT64_INPUTS(j) { CHECK_EQ((*i) & (*j), r.Call(*i, *j)); }
}
}
-// kExprI64Ior:
-TEST(Run_Wasm_I64Ior) {
+
+WASM_EXEC_TEST(I64Ior) {
REQUIRE(I64Ior);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_IOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -305,8 +291,8 @@
FOR_INT64_INPUTS(j) { CHECK_EQ((*i) | (*j), r.Call(*i, *j)); }
}
}
-// kExprI64Xor:
-TEST(Run_Wasm_I64Xor) {
+
+WASM_EXEC_TEST(I64Xor) {
REQUIRE(I64Xor);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -314,8 +300,8 @@
FOR_INT64_INPUTS(j) { CHECK_EQ((*i) ^ (*j), r.Call(*i, *j)); }
}
}
-// kExprI64Shl:
-TEST(Run_Wasm_I64Shl) {
+
+WASM_EXEC_TEST(I64Shl) {
REQUIRE(I64Shl);
{
WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
@@ -349,8 +335,8 @@
FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 40, r.Call(*i)); }
}
}
-// kExprI64ShrU:
-TEST(Run_Wasm_I64ShrU) {
+
+WASM_EXEC_TEST(I64ShrU) {
REQUIRE(I64ShrU);
{
WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
@@ -384,8 +370,8 @@
FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); }
}
}
-// kExprI64ShrS:
-TEST(Run_Wasm_I64ShrS) {
+
+WASM_EXEC_TEST(I64ShrS) {
REQUIRE(I64ShrS);
{
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
@@ -419,8 +405,8 @@
FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); }
}
}
-// kExprI64Eq:
-TEST(Run_Wasm_I64Eq) {
+
+WASM_EXEC_TEST(I64Eq) {
REQUIRE(I64Eq);
WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_EQ(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -428,8 +414,8 @@
FOR_INT64_INPUTS(j) { CHECK_EQ(*i == *j ? 1 : 0, r.Call(*i, *j)); }
}
}
-// kExprI64Ne:
-TEST(Run_Wasm_I64Ne) {
+
+WASM_EXEC_TEST(I64Ne) {
REQUIRE(I64Ne);
WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_NE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -437,8 +423,8 @@
FOR_INT64_INPUTS(j) { CHECK_EQ(*i != *j ? 1 : 0, r.Call(*i, *j)); }
}
}
-// kExprI64LtS:
-TEST(Run_Wasm_I64LtS) {
+
+WASM_EXEC_TEST(I64LtS) {
REQUIRE(I64LtS);
WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_LTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -446,7 +432,8 @@
FOR_INT64_INPUTS(j) { CHECK_EQ(*i < *j ? 1 : 0, r.Call(*i, *j)); }
}
}
-TEST(Run_Wasm_I64LeS) {
+
+WASM_EXEC_TEST(I64LeS) {
REQUIRE(I64LeS);
WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_LES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -454,7 +441,8 @@
FOR_INT64_INPUTS(j) { CHECK_EQ(*i <= *j ? 1 : 0, r.Call(*i, *j)); }
}
}
-TEST(Run_Wasm_I64LtU) {
+
+WASM_EXEC_TEST(I64LtU) {
REQUIRE(I64LtU);
WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_LTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -462,7 +450,8 @@
FOR_UINT64_INPUTS(j) { CHECK_EQ(*i < *j ? 1 : 0, r.Call(*i, *j)); }
}
}
-TEST(Run_Wasm_I64LeU) {
+
+WASM_EXEC_TEST(I64LeU) {
REQUIRE(I64LeU);
WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_LEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -470,7 +459,8 @@
FOR_UINT64_INPUTS(j) { CHECK_EQ(*i <= *j ? 1 : 0, r.Call(*i, *j)); }
}
}
-TEST(Run_Wasm_I64GtS) {
+
+WASM_EXEC_TEST(I64GtS) {
REQUIRE(I64GtS);
WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_GTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -478,7 +468,8 @@
FOR_INT64_INPUTS(j) { CHECK_EQ(*i > *j ? 1 : 0, r.Call(*i, *j)); }
}
}
-TEST(Run_Wasm_I64GeS) {
+
+WASM_EXEC_TEST(I64GeS) {
REQUIRE(I64GeS);
WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_GES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -487,7 +478,7 @@
}
}
-TEST(Run_Wasm_I64GtU) {
+WASM_EXEC_TEST(I64GtU) {
REQUIRE(I64GtU);
WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_GTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -496,7 +487,7 @@
}
}
-TEST(Run_Wasm_I64GeU) {
+WASM_EXEC_TEST(I64GeU) {
REQUIRE(I64GeU);
WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_GEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -504,8 +495,8 @@
FOR_UINT64_INPUTS(j) { CHECK_EQ(*i >= *j ? 1 : 0, r.Call(*i, *j)); }
}
}
-// kExprI32ConvertI64:
-TEST(Run_Wasm_I32ConvertI64) {
+
+WASM_EXEC_TEST(I32ConvertI64) {
REQUIRE(I32ConvertI64);
FOR_INT64_INPUTS(i) {
WasmRunner<int32_t> r;
@@ -513,29 +504,22 @@
CHECK_EQ(static_cast<int32_t>(*i), r.Call());
}
}
-// kExprI64SConvertI32:
-TEST(Run_Wasm_I64SConvertI32) {
+
+WASM_EXEC_TEST(I64SConvertI32) {
REQUIRE(I64SConvertI32);
WasmRunner<int64_t> r(MachineType::Int32());
BUILD(r, WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0)));
FOR_INT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); }
}
-// kExprI64UConvertI32:
-TEST(Run_Wasm_I64UConvertI32) {
+WASM_EXEC_TEST(I64UConvertI32) {
REQUIRE(I64UConvertI32);
WasmRunner<int64_t> r(MachineType::Uint32());
BUILD(r, WASM_I64_UCONVERT_I32(WASM_GET_LOCAL(0)));
FOR_UINT32_INPUTS(i) { CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); }
}
-// kExprF64ReinterpretI64:
-// kExprI64ReinterpretF64:
-
-// kExprI64Clz:
-// kExprI64Ctz:
-// kExprI64Popcnt:
-TEST(Run_WasmI64Popcnt) {
+WASM_EXEC_TEST(I64Popcnt) {
struct {
int64_t expected;
uint64_t input;
@@ -552,15 +536,14 @@
}
}
-// kExprF32SConvertI64:
-TEST(Run_WasmF32SConvertI64) {
+WASM_EXEC_TEST(F32SConvertI64) {
REQUIRE(F32SConvertI64);
WasmRunner<float> r(MachineType::Int64());
BUILD(r, WASM_F32_SCONVERT_I64(WASM_GET_LOCAL(0)));
FOR_INT64_INPUTS(i) { CHECK_FLOAT_EQ(static_cast<float>(*i), r.Call(*i)); }
}
-// kExprF32UConvertI64:
-TEST(Run_WasmF32UConvertI64) {
+
+WASM_EXEC_TEST(F32UConvertI64) {
REQUIRE(F32UConvertI64);
struct {
uint64_t input;
@@ -647,15 +630,15 @@
CHECK_EQ(bit_cast<float>(values[i].expected), r.Call(values[i].input));
}
}
-// kExprF64SConvertI64:
-TEST(Run_WasmF64SConvertI64) {
+
+WASM_EXEC_TEST(F64SConvertI64) {
REQUIRE(F64SConvertI64);
WasmRunner<double> r(MachineType::Int64());
BUILD(r, WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0)));
FOR_INT64_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(*i), r.Call(*i)); }
}
-// kExprF64UConvertI64:
-TEST(Run_Wasm_F64UConvertI64) {
+
+WASM_EXEC_TEST(F64UConvertI64) {
REQUIRE(F64UConvertI64);
struct {
uint64_t input;
@@ -741,9 +724,8 @@
CHECK_EQ(bit_cast<double>(values[i].expected), r.Call(values[i].input));
}
}
-// kExprI64SConvertF32:
-TEST(Run_Wasm_I64SConvertF32a) {
+WASM_EXEC_TEST(I64SConvertF32a) {
WasmRunner<int64_t> r(MachineType::Float32());
BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0)));
@@ -756,8 +738,8 @@
}
}
}
-// kExprI64SConvertF64:
-TEST(Run_Wasm_I64SConvertF64a) {
+
+WASM_EXEC_TEST(I64SConvertF64a) {
WasmRunner<int64_t> r(MachineType::Float64());
BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0)));
@@ -771,8 +753,7 @@
}
}
-// kExprI64UConvertF32:
-TEST(Run_Wasm_I64UConvertF32a) {
+WASM_EXEC_TEST(I64UConvertF32a) {
WasmRunner<uint64_t> r(MachineType::Float32());
BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0)));
@@ -786,8 +767,7 @@
}
}
-// kExprI64UConvertF64:
-TEST(Run_Wasm_I64UConvertF64a) {
+WASM_EXEC_TEST(I64UConvertF64a) {
WasmRunner<uint64_t> r(MachineType::Float64());
BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0)));
@@ -801,7 +781,7 @@
}
}
-TEST(Run_WasmCallI64Parameter) {
+WASM_EXEC_TEST(CallI64Parameter) {
// Build the target function.
LocalType param_types[20];
for (int i = 0; i < 20; i++) param_types[i] = kAstI64;
@@ -822,8 +802,8 @@
WasmRunner<int32_t> r(&module);
BUILD(
r,
- WASM_I32_CONVERT_I64(WASM_CALL_FUNCTION(
- index, WASM_I64V_9(0xbcd12340000000b),
+ WASM_I32_CONVERT_I64(WASM_CALL_FUNCTIONN(
+ 19, index, WASM_I64V_9(0xbcd12340000000b),
WASM_I64V_9(0xbcd12340000000c), WASM_I32V_1(0xd),
WASM_I32_CONVERT_I64(WASM_I64V_9(0xbcd12340000000e)),
WASM_I64V_9(0xbcd12340000000f), WASM_I64V_10(0xbcd1234000000010),
@@ -875,7 +855,7 @@
TestI64Binop(kExpr##name, expected, a, b); \
} while (false)
-TEST(Run_Wasm_I64Binops) {
+WASM_EXEC_TEST(I64Binops) {
TEST_I64_BINOP(I64Add, -5586332274295447011, 0x501b72ebabc26847,
0x625de9793d8f79d6);
TEST_I64_BINOP(I64Sub, 9001903251710731490, 0xf24fe6474640002e,
@@ -912,7 +892,7 @@
if (WASM_64 || kSupported_##name) TestI64Cmp(kExpr##name, expected, a, b); \
} while (false)
-TEST(Run_Wasm_I64Compare) {
+WASM_EXEC_TEST(I64Compare) {
TEST_I64_CMP(I64Eq, 0, 0xB915D8FA494064F0, 0x04D700B2536019A3);
TEST_I64_CMP(I64Ne, 1, 0xC2FAFAAAB0446CDC, 0x52A3328F780C97A3);
TEST_I64_CMP(I64LtS, 0, 0x673636E6306B0578, 0x028EC9ECA78F7227);
@@ -925,7 +905,7 @@
TEST_I64_CMP(I64GeU, 0, 0x0886A0C58C7AA224, 0x5DDBE5A81FD7EE47);
}
-TEST(Run_Wasm_I64Clz) {
+WASM_EXEC_TEST(I64Clz) {
REQUIRE(I64Clz);
struct {
int64_t expected;
@@ -971,7 +951,7 @@
}
}
-TEST(Run_Wasm_I64Ctz) {
+WASM_EXEC_TEST(I64Ctz) {
REQUIRE(I64Ctz);
struct {
int64_t expected;
@@ -1017,7 +997,7 @@
}
}
-TEST(Run_Wasm_I64Popcnt) {
+WASM_EXEC_TEST(I64Popcnt2) {
REQUIRE(I64Popcnt);
struct {
int64_t expected;
@@ -1088,7 +1068,7 @@
}
}
-TEST(Run_WasmCall_Int64Sub) {
+WASM_EXEC_TEST(Call_Int64Sub) {
REQUIRE(I64Sub);
// Build the target function.
TestSignatures sigs;
@@ -1099,7 +1079,7 @@
// Build the caller function.
WasmRunner<int64_t> r(&module, MachineType::Int64(), MachineType::Int64());
- BUILD(r, WASM_CALL_FUNCTION(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+ BUILD(r, WASM_CALL_FUNCTION2(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
@@ -1115,7 +1095,7 @@
}
}
-TEST(Run_Wasm_LoadStoreI64_sx) {
+WASM_EXEC_TEST(LoadStoreI64_sx) {
REQUIRE(I64LoadStore);
REQUIRE(DepthFirst);
byte loads[] = {kExprI64LoadMem8S, kExprI64LoadMem16S, kExprI64LoadMem32S,
@@ -1126,12 +1106,16 @@
byte* memory = module.AddMemoryElems<byte>(16);
WasmRunner<int64_t> r(&module);
- byte code[] = {kExprI64StoreMem, ZERO_ALIGNMENT,
- ZERO_OFFSET, // --
- kExprI8Const, 8, // --
- loads[m], ZERO_ALIGNMENT,
- ZERO_OFFSET, // --
- kExprI8Const, 0}; // --
+ byte code[] = {
+ kExprI8Const, 8, // --
+ kExprI8Const, 0, // --
+ loads[m], // --
+ ZERO_ALIGNMENT, // --
+ ZERO_OFFSET, // --
+ kExprI64StoreMem, // --
+ ZERO_ALIGNMENT, // --
+ ZERO_OFFSET // --
+ };
r.Build(code, code + arraysize(code));
@@ -1152,7 +1136,7 @@
}
}
-TEST(Run_Wasm_I64SConvertF32b) {
+WASM_EXEC_TEST(I64SConvertF32b) {
REQUIRE(I64SConvertF32);
WasmRunner<int64_t> r(MachineType::Float32());
BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0)));
@@ -1167,7 +1151,7 @@
}
}
-TEST(Run_Wasm_I64SConvertF64b) {
+WASM_EXEC_TEST(I64SConvertF64b) {
REQUIRE(I64SConvertF64);
WasmRunner<int64_t> r(MachineType::Float64());
BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0)));
@@ -1182,7 +1166,7 @@
}
}
-TEST(Run_Wasm_I64UConvertF32b) {
+WASM_EXEC_TEST(I64UConvertF32b) {
REQUIRE(I64UConvertF32);
WasmRunner<uint64_t> r(MachineType::Float32());
BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0)));
@@ -1196,7 +1180,7 @@
}
}
-TEST(Run_Wasm_I64UConvertF64b) {
+WASM_EXEC_TEST(I64UConvertF64b) {
REQUIRE(I64UConvertF64);
WasmRunner<uint64_t> r(MachineType::Float64());
BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0)));
@@ -1210,7 +1194,7 @@
}
}
-TEST(Run_Wasm_I64ReinterpretF64) {
+WASM_EXEC_TEST(I64ReinterpretF64) {
REQUIRE(I64ReinterpretF64);
TestingModule module;
int64_t* memory = module.AddMemoryElems<int64_t>(8);
@@ -1226,7 +1210,7 @@
}
}
-TEST(Run_Wasm_F64ReinterpretI64) {
+WASM_EXEC_TEST(F64ReinterpretI64) {
REQUIRE(F64ReinterpretI64);
TestingModule module;
int64_t* memory = module.AddMemoryElems<int64_t>(8);
@@ -1244,7 +1228,7 @@
}
}
-TEST(Run_Wasm_LoadMemI64) {
+WASM_EXEC_TEST(LoadMemI64) {
REQUIRE(I64LoadStore);
TestingModule module;
int64_t* memory = module.AddMemoryElems<int64_t>(8);
@@ -1263,7 +1247,7 @@
CHECK_EQ(77777777, r.Call());
}
-TEST(Run_Wasm_MemI64_Sum) {
+WASM_EXEC_TEST(MemI64_Sum) {
REQUIRE(I64LoadStore);
REQUIRE(I64Add);
REQUIRE(I64Sub);
@@ -1299,7 +1283,7 @@
}
}
-TEST(Run_Wasm_I64Global) {
+WASM_EXEC_TEST(I64Global) {
REQUIRE(I64LoadStore);
REQUIRE(I64SConvertI32);
REQUIRE(I64And);
@@ -1321,7 +1305,7 @@
}
}
-TEST(Run_Wasm_I64Eqz) {
+WASM_EXEC_TEST(I64Eqz) {
REQUIRE(I64Eq);
WasmRunner<int32_t> r(MachineType::Int64());
@@ -1333,7 +1317,7 @@
}
}
-TEST(Run_Wasm_I64Ror) {
+WASM_EXEC_TEST(I64Ror) {
REQUIRE(I64Ror);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_ROR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -1346,7 +1330,7 @@
}
}
-TEST(Run_Wasm_I64Rol) {
+WASM_EXEC_TEST(I64Rol) {
REQUIRE(I64Rol);
WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_ROL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
diff --git a/test/cctest/wasm/test-run-wasm-asmjs.cc b/test/cctest/wasm/test-run-wasm-asmjs.cc
new file mode 100644
index 0000000..c597fc8
--- /dev/null
+++ b/test/cctest/wasm/test-run-wasm-asmjs.cc
@@ -0,0 +1,195 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "src/base/platform/elapsed-timer.h"
+
+#include "src/wasm/wasm-macro-gen.h"
+
+#include "test/cctest/cctest.h"
+#include "test/cctest/compiler/value-helper.h"
+#include "test/cctest/wasm/test-signatures.h"
+#include "test/cctest/wasm/wasm-run-utils.h"
+
+using namespace v8::base;
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+using namespace v8::internal::wasm;
+
+// for even shorter tests.
+#define B2(a, b) kExprBlock, a, b, kExprEnd
+#define B1(a) kExprBlock, a, kExprEnd
+#define RET(x) x, kExprReturn, 1
+#define RET_I8(x) kExprI8Const, x, kExprReturn, 1
+
+WASM_EXEC_TEST(Int32AsmjsDivS) {
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ BUILD(r, WASM_BINOP(kExprI32AsmjsDivS, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+ const int32_t kMin = std::numeric_limits<int32_t>::min();
+ CHECK_EQ(0, r.Call(0, 100));
+ CHECK_EQ(0, r.Call(100, 0));
+ CHECK_EQ(0, r.Call(-1001, 0));
+ CHECK_EQ(kMin, r.Call(kMin, -1));
+ CHECK_EQ(0, r.Call(kMin, 0));
+}
+
+WASM_EXEC_TEST(Int32AsmjsRemS) {
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ BUILD(r, WASM_BINOP(kExprI32AsmjsRemS, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+ const int32_t kMin = std::numeric_limits<int32_t>::min();
+ CHECK_EQ(33, r.Call(133, 100));
+ CHECK_EQ(0, r.Call(kMin, -1));
+ CHECK_EQ(0, r.Call(100, 0));
+ CHECK_EQ(0, r.Call(-1001, 0));
+ CHECK_EQ(0, r.Call(kMin, 0));
+}
+
+WASM_EXEC_TEST(Int32AsmjsDivU) {
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ BUILD(r, WASM_BINOP(kExprI32AsmjsDivU, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+ const int32_t kMin = std::numeric_limits<int32_t>::min();
+ CHECK_EQ(0, r.Call(0, 100));
+ CHECK_EQ(0, r.Call(kMin, -1));
+ CHECK_EQ(0, r.Call(100, 0));
+ CHECK_EQ(0, r.Call(-1001, 0));
+ CHECK_EQ(0, r.Call(kMin, 0));
+}
+
+WASM_EXEC_TEST(Int32AsmjsRemU) {
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ BUILD(r, WASM_BINOP(kExprI32AsmjsRemU, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+ const int32_t kMin = std::numeric_limits<int32_t>::min();
+ CHECK_EQ(17, r.Call(217, 100));
+ CHECK_EQ(0, r.Call(100, 0));
+ CHECK_EQ(0, r.Call(-1001, 0));
+ CHECK_EQ(0, r.Call(kMin, 0));
+ CHECK_EQ(kMin, r.Call(kMin, -1));
+}
+
+WASM_EXEC_TEST(I32AsmjsSConvertF32) {
+ WasmRunner<int32_t> r(MachineType::Float32());
+ BUILD(r, WASM_UNOP(kExprI32AsmjsSConvertF32, WASM_GET_LOCAL(0)));
+
+ FOR_FLOAT32_INPUTS(i) {
+ int32_t expected = DoubleToInt32(*i);
+ CHECK_EQ(expected, r.Call(*i));
+ }
+}
+
+WASM_EXEC_TEST(I32AsmjsSConvertF64) {
+ WasmRunner<int32_t> r(MachineType::Float64());
+ BUILD(r, WASM_UNOP(kExprI32AsmjsSConvertF64, WASM_GET_LOCAL(0)));
+
+ FOR_FLOAT64_INPUTS(i) {
+ int32_t expected = DoubleToInt32(*i);
+ CHECK_EQ(expected, r.Call(*i));
+ }
+}
+
+WASM_EXEC_TEST(I32AsmjsUConvertF32) {
+ WasmRunner<uint32_t> r(MachineType::Float32());
+ BUILD(r, WASM_UNOP(kExprI32AsmjsUConvertF32, WASM_GET_LOCAL(0)));
+
+ FOR_FLOAT32_INPUTS(i) {
+ uint32_t expected = DoubleToUint32(*i);
+ CHECK_EQ(expected, r.Call(*i));
+ }
+}
+
+WASM_EXEC_TEST(I32AsmjsUConvertF64) {
+ WasmRunner<uint32_t> r(MachineType::Float64());
+ BUILD(r, WASM_UNOP(kExprI32AsmjsUConvertF64, WASM_GET_LOCAL(0)));
+
+ FOR_FLOAT64_INPUTS(i) {
+ uint32_t expected = DoubleToUint32(*i);
+ CHECK_EQ(expected, r.Call(*i));
+ }
+}
+
+WASM_EXEC_TEST(LoadMemI32_oob_asm) {
+ TestingModule module;
+ int32_t* memory = module.AddMemoryElems<int32_t>(8);
+ WasmRunner<int32_t> r(&module, MachineType::Uint32());
+ module.RandomizeMemory(1112);
+
+ BUILD(r, WASM_UNOP(kExprI32AsmjsLoadMem, WASM_GET_LOCAL(0)));
+
+ memory[0] = 999999;
+ CHECK_EQ(999999, r.Call(0u));
+ // TODO(titzer): offset 29-31 should also be OOB.
+ for (uint32_t offset = 32; offset < 40; offset++) {
+ CHECK_EQ(0, r.Call(offset));
+ }
+
+ for (uint32_t offset = 0x80000000; offset < 0x80000010; offset++) {
+ CHECK_EQ(0, r.Call(offset));
+ }
+}
+
+WASM_EXEC_TEST(LoadMemF32_oob_asm) {
+ TestingModule module;
+ float* memory = module.AddMemoryElems<float>(8);
+ WasmRunner<float> r(&module, MachineType::Uint32());
+ module.RandomizeMemory(1112);
+
+ BUILD(r, WASM_UNOP(kExprF32AsmjsLoadMem, WASM_GET_LOCAL(0)));
+
+ memory[0] = 9999.5f;
+ CHECK_EQ(9999.5f, r.Call(0u));
+ // TODO(titzer): offset 29-31 should also be OOB.
+ for (uint32_t offset = 32; offset < 40; offset++) {
+ CHECK(std::isnan(r.Call(offset)));
+ }
+
+ for (uint32_t offset = 0x80000000; offset < 0x80000010; offset++) {
+ CHECK(std::isnan(r.Call(offset)));
+ }
+}
+
+WASM_EXEC_TEST(LoadMemF64_oob_asm) {
+ TestingModule module;
+ double* memory = module.AddMemoryElems<double>(8);
+ WasmRunner<double> r(&module, MachineType::Uint32());
+ module.RandomizeMemory(1112);
+
+ BUILD(r, WASM_UNOP(kExprF64AsmjsLoadMem, WASM_GET_LOCAL(0)));
+
+ memory[0] = 9799.5;
+ CHECK_EQ(9799.5, r.Call(0u));
+ memory[1] = 11799.25;
+ CHECK_EQ(11799.25, r.Call(8u));
+ // TODO(titzer): offset 57-63 should also be OOB.
+ for (uint32_t offset = 64; offset < 80; offset++) {
+ CHECK(std::isnan(r.Call(offset)));
+ }
+
+ for (uint32_t offset = 0x80000000; offset < 0x80000010; offset++) {
+ CHECK(std::isnan(r.Call(offset)));
+ }
+}
+
+WASM_EXEC_TEST(StoreMemI32_oob_asm) {
+ TestingModule module;
+ int32_t* memory = module.AddMemoryElems<int32_t>(8);
+ WasmRunner<int32_t> r(&module, MachineType::Uint32(), MachineType::Uint32());
+ module.RandomizeMemory(1112);
+
+ BUILD(r, WASM_BINOP(kExprI32AsmjsStoreMem, WASM_GET_LOCAL(0),
+ WASM_GET_LOCAL(1)));
+
+ memory[0] = 7777;
+ CHECK_EQ(999999, r.Call(0u, 999999));
+ CHECK_EQ(999999, memory[0]);
+ // TODO(titzer): offset 29-31 should also be OOB.
+ for (uint32_t offset = 32; offset < 40; offset++) {
+ CHECK_EQ(8888, r.Call(offset, 8888));
+ }
+
+ for (uint32_t offset = 0x10000000; offset < 0xF0000000; offset += 0x1000000) {
+ CHECK_EQ(7777, r.Call(offset, 7777));
+ }
+}
diff --git a/test/cctest/wasm/test-run-wasm-js.cc b/test/cctest/wasm/test-run-wasm-js.cc
index 6d95d6e..827cb3a 100644
--- a/test/cctest/wasm/test-run-wasm-js.cc
+++ b/test/cctest/wasm/test-run-wasm-js.cc
@@ -25,14 +25,12 @@
r.Build(code, code + arraysize(code)); \
} while (false)
-
#define ADD_CODE(vec, ...) \
do { \
byte __buf[] = {__VA_ARGS__}; \
for (size_t i = 0; i < sizeof(__buf); i++) vec.push_back(__buf[i]); \
} while (false)
-
namespace {
// A helper for generating predictable but unique argument values that
// are easy to debug (e.g. with misaligned stacks).
@@ -48,23 +46,6 @@
}
};
-
-uint32_t AddJsFunction(TestingModule* module, FunctionSig* sig,
- const char* source) {
- Handle<JSFunction> jsfunc = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
- *v8::Local<v8::Function>::Cast(CompileRun(source))));
- module->AddFunction(sig, Handle<Code>::null());
- uint32_t index = static_cast<uint32_t>(module->module->functions.size() - 1);
- Isolate* isolate = CcTest::InitIsolateOnce();
- WasmName module_name = {"test", 4};
- WasmName function_name = {nullptr, 0};
- Handle<Code> code = CompileWasmToJSWrapper(isolate, module, jsfunc, sig,
- module_name, function_name);
- module->instance->function_code[index] = code;
- return index;
-}
-
-
uint32_t AddJSSelector(TestingModule* module, FunctionSig* sig, int which) {
const int kMaxParams = 11;
static const char* formals[kMaxParams] = {"",
@@ -86,22 +67,9 @@
SNPrintF(source, "(function(%s) { return %c; })",
formals[sig->parameter_count()], param);
- return AddJsFunction(module, sig, source.start());
+ return module->AddJsFunction(sig, source.start());
}
-
-Handle<JSFunction> WrapCode(ModuleEnv* module, uint32_t index) {
- Isolate* isolate = module->module->shared_isolate;
- // Wrap the code so it can be called as a JS function.
- Handle<String> name = isolate->factory()->NewStringFromStaticChars("main");
- Handle<JSObject> module_object = Handle<JSObject>(0, isolate);
- Handle<Code> code = module->instance->function_code[index];
- WasmJs::InstallWasmFunctionMap(isolate, isolate->native_context());
- return compiler::CompileJSToWasmWrapper(isolate, module, name, code,
- module_object, index);
-}
-
-
void EXPECT_CALL(double expected, Handle<JSFunction> jsfunc,
Handle<Object>* buffer, int count) {
Isolate* isolate = jsfunc->GetIsolate();
@@ -119,7 +87,6 @@
}
}
-
void EXPECT_CALL(double expected, Handle<JSFunction> jsfunc, double a,
double b) {
Isolate* isolate = jsfunc->GetIsolate();
@@ -134,68 +101,61 @@
TestingModule module;
WasmFunctionCompiler t(sigs.i_ii(), &module);
BUILD(t, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
- Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd());
+ Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
EXPECT_CALL(33, jsfunc, 44, 11);
EXPECT_CALL(-8723487, jsfunc, -8000000, 723487);
}
-
TEST(Run_Float32Div_jswrapped) {
TestSignatures sigs;
TestingModule module;
WasmFunctionCompiler t(sigs.f_ff(), &module);
BUILD(t, WASM_F32_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
- Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd());
+ Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
EXPECT_CALL(92, jsfunc, 46, 0.5);
EXPECT_CALL(64, jsfunc, -16, -0.25);
}
-
TEST(Run_Float64Add_jswrapped) {
TestSignatures sigs;
TestingModule module;
WasmFunctionCompiler t(sigs.d_dd(), &module);
BUILD(t, WASM_F64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
- Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd());
+ Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
EXPECT_CALL(3, jsfunc, 2, 1);
EXPECT_CALL(-5.5, jsfunc, -5.25, -0.25);
}
-
TEST(Run_I32Popcount_jswrapped) {
TestSignatures sigs;
TestingModule module;
WasmFunctionCompiler t(sigs.i_i(), &module);
BUILD(t, WASM_I32_POPCNT(WASM_GET_LOCAL(0)));
- Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd());
+ Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
EXPECT_CALL(2, jsfunc, 9, 0);
EXPECT_CALL(3, jsfunc, 11, 0);
EXPECT_CALL(6, jsfunc, 0x3F, 0);
-
- USE(AddJsFunction);
}
-
TEST(Run_CallJS_Add_jswrapped) {
TestSignatures sigs;
TestingModule module;
WasmFunctionCompiler t(sigs.i_i(), &module);
uint32_t js_index =
- AddJsFunction(&module, sigs.i_i(), "(function(a) { return a + 99; })");
- BUILD(t, WASM_CALL_FUNCTION(js_index, WASM_GET_LOCAL(0)));
+ module.AddJsFunction(sigs.i_i(), "(function(a) { return a + 99; })");
+ BUILD(t, WASM_CALL_FUNCTION1(js_index, WASM_GET_LOCAL(0)));
- Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd());
+ Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
EXPECT_CALL(101, jsfunc, 2, -8);
EXPECT_CALL(199, jsfunc, 100, -1);
EXPECT_CALL(-666666801, jsfunc, -666666900, -1);
}
-
void RunJSSelectTest(int which) {
const int kMaxParams = 8;
PredictableInputValues inputs(0x100);
@@ -212,24 +172,25 @@
{
std::vector<byte> code;
- ADD_CODE(code, kExprCallFunction, static_cast<byte>(js_index));
for (int i = 0; i < num_params; i++) {
ADD_CODE(code, WASM_F64(inputs.arg_d(i)));
}
+ ADD_CODE(code, kExprCallFunction, static_cast<byte>(num_params),
+ static_cast<byte>(js_index));
+
size_t end = code.size();
code.push_back(0);
t.Build(&code[0], &code[end]);
}
- Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd());
+ Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
double expected = inputs.arg_d(which);
EXPECT_CALL(expected, jsfunc, 0.0, 0.0);
}
}
-
TEST(Run_JSSelect_0) { RunJSSelectTest(0); }
TEST(Run_JSSelect_1) { RunJSSelectTest(1); }
@@ -246,7 +207,6 @@
TEST(Run_JSSelect_7) { RunJSSelectTest(7); }
-
void RunWASMSelectTest(int which) {
PredictableInputValues inputs(0x200);
Isolate* isolate = CcTest::InitIsolateOnce();
@@ -260,7 +220,7 @@
TestingModule module;
WasmFunctionCompiler t(&sig, &module);
BUILD(t, WASM_GET_LOCAL(which));
- Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd());
+ Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
Handle<Object> args[] = {
isolate->factory()->NewNumber(inputs.arg_d(0)),
@@ -278,7 +238,6 @@
}
}
-
TEST(Run_WASMSelect_0) { RunWASMSelectTest(0); }
TEST(Run_WASMSelect_1) { RunWASMSelectTest(1); }
@@ -295,7 +254,6 @@
TEST(Run_WASMSelect_7) { RunWASMSelectTest(7); }
-
void RunWASMSelectAlignTest(int num_args, int num_params) {
PredictableInputValues inputs(0x300);
Isolate* isolate = CcTest::InitIsolateOnce();
@@ -310,7 +268,7 @@
TestingModule module;
WasmFunctionCompiler t(&sig, &module);
BUILD(t, WASM_GET_LOCAL(which));
- Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd());
+ Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
Handle<Object> args[] = {isolate->factory()->NewNumber(inputs.arg_d(0)),
isolate->factory()->NewNumber(inputs.arg_d(1)),
@@ -329,31 +287,26 @@
}
}
-
TEST(Run_WASMSelectAlign_0) {
RunWASMSelectAlignTest(0, 1);
RunWASMSelectAlignTest(0, 2);
}
-
TEST(Run_WASMSelectAlign_1) {
RunWASMSelectAlignTest(1, 2);
RunWASMSelectAlignTest(1, 3);
}
-
TEST(Run_WASMSelectAlign_2) {
RunWASMSelectAlignTest(2, 3);
RunWASMSelectAlignTest(2, 4);
}
-
TEST(Run_WASMSelectAlign_3) {
RunWASMSelectAlignTest(3, 3);
RunWASMSelectAlignTest(3, 4);
}
-
TEST(Run_WASMSelectAlign_4) {
RunWASMSelectAlignTest(4, 3);
RunWASMSelectAlignTest(4, 4);
@@ -400,12 +353,13 @@
// Build the calling code.
std::vector<byte> code;
- ADD_CODE(code, kExprCallFunction, 0);
for (int i = 0; i < num_params; i++) {
ADD_CODE(code, WASM_GET_LOCAL(i));
}
+ ADD_CODE(code, kExprCallFunction, static_cast<byte>(num_params), 0);
+
size_t end = code.size();
code.push_back(0);
@@ -418,7 +372,7 @@
WasmFunctionCompiler t(&sig, &module);
t.Build(&code[0], &code[end]);
- Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd());
+ Handle<JSFunction> jsfunc = module.WrapCode(t.CompileAndAdd());
Handle<Object> args[] = {
factory->NewNumber(inputs.arg_d(0)),
@@ -439,7 +393,6 @@
}
}
-
TEST(Run_JSSelectAlign_0) {
RunJSSelectAlignTest(0, 1);
RunJSSelectAlignTest(0, 2);
diff --git a/test/cctest/wasm/test-run-wasm-module.cc b/test/cctest/wasm/test-run-wasm-module.cc
index 118a91f..05edd62 100644
--- a/test/cctest/wasm/test-run-wasm-module.cc
+++ b/test/cctest/wasm/test-run-wasm-module.cc
@@ -12,14 +12,13 @@
#include "src/wasm/wasm-opcodes.h"
#include "test/cctest/cctest.h"
+#include "test/cctest/wasm/test-signatures.h"
using namespace v8::base;
using namespace v8::internal;
using namespace v8::internal::compiler;
using namespace v8::internal::wasm;
-
-// TODO(titzer): fix arm64 frame alignment.
namespace {
void TestModule(WasmModuleIndex* module, int32_t expected_result) {
Isolate* isolate = CcTest::InitIsolateOnce();
@@ -31,50 +30,16 @@
}
} // namespace
-
-// A raw test that skips the WasmModuleBuilder.
-TEST(Run_WasmModule_CallAdd_rev) {
- static const byte data[] = {
- WASM_MODULE_HEADER,
- // sig#0 ------------------------------------------
- WASM_SECTION_SIGNATURES_SIZE + 7, // Section size.
- WASM_SECTION_SIGNATURES, 2, 0, kLocalI32, // void -> int
- 2, kLocalI32, kLocalI32, kLocalI32, // int,int -> int
- // func#0 (main) ----------------------------------
- WASM_SECTION_FUNCTIONS_SIZE + 24, WASM_SECTION_FUNCTIONS, 2,
- kDeclFunctionExport, 0, 0, // sig index
- 7, 0, // body size
- 0, // locals
- kExprCallFunction, 1, // --
- kExprI8Const, 77, // --
- kExprI8Const, 22, // --
- // func#1 -----------------------------------------
- 0, // no name, not exported
- 1, 0, // sig index
- 6, 0, // body size
- 0, // locals
- kExprI32Add, // --
- kExprGetLocal, 0, // --
- kExprGetLocal, 1, // --
- };
-
- Isolate* isolate = CcTest::InitIsolateOnce();
- HandleScope scope(isolate);
- WasmJs::InstallWasmFunctionMap(isolate, isolate->native_context());
- int32_t result =
- CompileAndRunWasmModule(isolate, data, data + arraysize(data));
- CHECK_EQ(99, result);
-}
-
-
TEST(Run_WasmModule_Return114) {
static const int32_t kReturnValue = 114;
+ TestSignatures sigs;
v8::base::AccountingAllocator allocator;
Zone zone(&allocator);
+
WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
uint16_t f_index = builder->AddFunction();
WasmFunctionBuilder* f = builder->FunctionAt(f_index);
- f->ReturnType(kAstI32);
+ f->SetSignature(sigs.i_v());
f->Exported(1);
byte code[] = {WASM_I8(kReturnValue)};
f->EmitCode(code, sizeof(code));
@@ -82,38 +47,43 @@
TestModule(writer->WriteTo(&zone), kReturnValue);
}
-
TEST(Run_WasmModule_CallAdd) {
v8::base::AccountingAllocator allocator;
Zone zone(&allocator);
+ TestSignatures sigs;
+
WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
+
uint16_t f1_index = builder->AddFunction();
WasmFunctionBuilder* f = builder->FunctionAt(f1_index);
- f->ReturnType(kAstI32);
- uint16_t param1 = f->AddParam(kAstI32);
- uint16_t param2 = f->AddParam(kAstI32);
+ f->SetSignature(sigs.i_ii());
+ uint16_t param1 = 0;
+ uint16_t param2 = 1;
byte code1[] = {WASM_I32_ADD(WASM_GET_LOCAL(param1), WASM_GET_LOCAL(param2))};
- uint32_t local_indices1[] = {2, 4};
- f->EmitCode(code1, sizeof(code1), local_indices1, sizeof(local_indices1) / 4);
+ f->EmitCode(code1, sizeof(code1));
+
uint16_t f2_index = builder->AddFunction();
f = builder->FunctionAt(f2_index);
- f->ReturnType(kAstI32);
+ f->SetSignature(sigs.i_v());
+
f->Exported(1);
- byte code2[] = {WASM_CALL_FUNCTION(f1_index, WASM_I8(77), WASM_I8(22))};
+ byte code2[] = {WASM_CALL_FUNCTION2(f1_index, WASM_I8(77), WASM_I8(22))};
f->EmitCode(code2, sizeof(code2));
WasmModuleWriter* writer = builder->Build(&zone);
TestModule(writer->WriteTo(&zone), 99);
}
-
TEST(Run_WasmModule_ReadLoadedDataSegment) {
static const byte kDataSegmentDest0 = 12;
v8::base::AccountingAllocator allocator;
Zone zone(&allocator);
+ TestSignatures sigs;
+
WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
uint16_t f_index = builder->AddFunction();
WasmFunctionBuilder* f = builder->FunctionAt(f_index);
- f->ReturnType(kAstI32);
+ f->SetSignature(sigs.i_v());
+
f->Exported(1);
byte code[] = {
WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(kDataSegmentDest0))};
@@ -129,10 +99,13 @@
static const int kCheckSize = 16 * 1024;
v8::base::AccountingAllocator allocator;
Zone zone(&allocator);
+ TestSignatures sigs;
+
WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
uint16_t f_index = builder->AddFunction();
WasmFunctionBuilder* f = builder->FunctionAt(f_index);
- f->ReturnType(kAstI32);
+ f->SetSignature(sigs.i_v());
+
uint16_t localIndex = f->AddLocal(kAstI32);
f->Exported(1);
byte code[] = {WASM_BLOCK(
@@ -143,7 +116,7 @@
WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(localIndex)),
WASM_BRV(2, WASM_I8(-1)), WASM_INC_LOCAL_BY(localIndex, 4))),
WASM_I8(11))};
- f->EmitCode(code, sizeof(code), nullptr, 0);
+ f->EmitCode(code, sizeof(code));
WasmModuleWriter* writer = builder->Build(&zone);
TestModule(writer->WriteTo(&zone), 11);
}
@@ -151,10 +124,13 @@
TEST(Run_WasmModule_CallMain_recursive) {
v8::base::AccountingAllocator allocator;
Zone zone(&allocator);
+ TestSignatures sigs;
+
WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
uint16_t f_index = builder->AddFunction();
WasmFunctionBuilder* f = builder->FunctionAt(f_index);
- f->ReturnType(kAstI32);
+ f->SetSignature(sigs.i_v());
+
uint16_t localIndex = f->AddLocal(kAstI32);
f->Exported(1);
byte code[] = {WASM_BLOCK(
@@ -165,7 +141,7 @@
WASM_INC_LOCAL(localIndex)),
WASM_BRV(1, WASM_CALL_FUNCTION0(0))),
WASM_BRV(0, WASM_I8(55))))};
- f->EmitCode(code, sizeof(code), nullptr, 0);
+ f->EmitCode(code, sizeof(code));
WasmModuleWriter* writer = builder->Build(&zone);
TestModule(writer->WriteTo(&zone), 55);
}
@@ -173,22 +149,24 @@
TEST(Run_WasmModule_Global) {
v8::base::AccountingAllocator allocator;
Zone zone(&allocator);
+ TestSignatures sigs;
+
WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
uint32_t global1 = builder->AddGlobal(MachineType::Int32(), 0);
uint32_t global2 = builder->AddGlobal(MachineType::Int32(), 0);
uint16_t f1_index = builder->AddFunction();
WasmFunctionBuilder* f = builder->FunctionAt(f1_index);
- f->ReturnType(kAstI32);
+ f->SetSignature(sigs.i_v());
byte code1[] = {
WASM_I32_ADD(WASM_LOAD_GLOBAL(global1), WASM_LOAD_GLOBAL(global2))};
f->EmitCode(code1, sizeof(code1));
uint16_t f2_index = builder->AddFunction();
f = builder->FunctionAt(f2_index);
- f->ReturnType(kAstI32);
+ f->SetSignature(sigs.i_v());
f->Exported(1);
byte code2[] = {WASM_STORE_GLOBAL(global1, WASM_I32V_1(56)),
WASM_STORE_GLOBAL(global2, WASM_I32V_1(41)),
- WASM_RETURN(WASM_CALL_FUNCTION0(f1_index))};
+ WASM_RETURN1(WASM_CALL_FUNCTION0(f1_index))};
f->EmitCode(code2, sizeof(code2));
WasmModuleWriter* writer = builder->Build(&zone);
TestModule(writer->WriteTo(&zone), 97);
diff --git a/test/cctest/wasm/test-run-wasm.cc b/test/cctest/wasm/test-run-wasm.cc
index 70d461b..236624f 100644
--- a/test/cctest/wasm/test-run-wasm.cc
+++ b/test/cctest/wasm/test-run-wasm.cc
@@ -6,6 +6,8 @@
#include <stdlib.h>
#include <string.h>
+#include "src/base/platform/elapsed-timer.h"
+
#include "src/wasm/wasm-macro-gen.h"
#include "test/cctest/cctest.h"
@@ -19,12 +21,12 @@
using namespace v8::internal::wasm;
// for even shorter tests.
-#define B2(a, b) kExprBlock, 2, a, b
-#define B1(a) kExprBlock, 1, a
-#define RET(x) kExprReturn, x
-#define RET_I8(x) kExprReturn, kExprI8Const, x
+#define B2(a, b) kExprBlock, a, b, kExprEnd
+#define B1(a) kExprBlock, a, kExprEnd
+#define RET(x) x, kExprReturn, 1
+#define RET_I8(x) kExprI8Const, x, kExprReturn, 1
-TEST(Run_WasmInt8Const) {
+WASM_EXEC_TEST(Int8Const) {
WasmRunner<int32_t> r;
const byte kExpectedValue = 121;
// return(kExpectedValue)
@@ -32,8 +34,7 @@
CHECK_EQ(kExpectedValue, r.Call());
}
-
-TEST(Run_WasmInt8Const_fallthru1) {
+WASM_EXEC_TEST(Int8Const_fallthru1) {
WasmRunner<int32_t> r;
const byte kExpectedValue = 122;
// kExpectedValue
@@ -41,8 +42,7 @@
CHECK_EQ(kExpectedValue, r.Call());
}
-
-TEST(Run_WasmInt8Const_fallthru2) {
+WASM_EXEC_TEST(Int8Const_fallthru2) {
WasmRunner<int32_t> r;
const byte kExpectedValue = 123;
// -99 kExpectedValue
@@ -50,8 +50,7 @@
CHECK_EQ(kExpectedValue, r.Call());
}
-
-TEST(Run_WasmInt8Const_all) {
+WASM_EXEC_TEST(Int8Const_all) {
for (int value = -128; value <= 127; value++) {
WasmRunner<int32_t> r;
// return(value)
@@ -61,8 +60,7 @@
}
}
-
-TEST(Run_WasmInt32Const) {
+WASM_EXEC_TEST(Int32Const) {
WasmRunner<int32_t> r;
const int32_t kExpectedValue = 0x11223344;
// return(kExpectedValue)
@@ -70,8 +68,7 @@
CHECK_EQ(kExpectedValue, r.Call());
}
-
-TEST(Run_WasmInt32Const_many) {
+WASM_EXEC_TEST(Int32Const_many) {
FOR_INT32_INPUTS(i) {
WasmRunner<int32_t> r;
const int32_t kExpectedValue = *i;
@@ -81,8 +78,7 @@
}
}
-
-TEST(Run_WasmMemorySize) {
+WASM_EXEC_TEST(MemorySize) {
TestingModule module;
WasmRunner<int32_t> r(&module);
module.AddMemory(1024);
@@ -90,56 +86,49 @@
CHECK_EQ(1024, r.Call());
}
-
-TEST(Run_WasmInt32Param0) {
+WASM_EXEC_TEST(Int32Param0) {
WasmRunner<int32_t> r(MachineType::Int32());
// return(local[0])
BUILD(r, WASM_GET_LOCAL(0));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
}
-
-TEST(Run_WasmInt32Param0_fallthru) {
+WASM_EXEC_TEST(Int32Param0_fallthru) {
WasmRunner<int32_t> r(MachineType::Int32());
// local[0]
BUILD(r, WASM_GET_LOCAL(0));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
}
-
-TEST(Run_WasmInt32Param1) {
+WASM_EXEC_TEST(Int32Param1) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
// local[1]
BUILD(r, WASM_GET_LOCAL(1));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(-111, *i)); }
}
-
-TEST(Run_WasmInt32Add) {
+WASM_EXEC_TEST(Int32Add) {
WasmRunner<int32_t> r;
// 11 + 44
BUILD(r, WASM_I32_ADD(WASM_I8(11), WASM_I8(44)));
CHECK_EQ(55, r.Call());
}
-
-TEST(Run_WasmInt32Add_P) {
+WASM_EXEC_TEST(Int32Add_P) {
WasmRunner<int32_t> r(MachineType::Int32());
// p0 + 13
BUILD(r, WASM_I32_ADD(WASM_I8(13), WASM_GET_LOCAL(0)));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i + 13, r.Call(*i)); }
}
-
-TEST(Run_WasmInt32Add_P_fallthru) {
+WASM_EXEC_TEST(Int32Add_P_fallthru) {
WasmRunner<int32_t> r(MachineType::Int32());
// p0 + 13
BUILD(r, WASM_I32_ADD(WASM_I8(13), WASM_GET_LOCAL(0)));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i + 13, r.Call(*i)); }
}
-
-TEST(Run_WasmInt32Add_P2) {
+WASM_EXEC_TEST(Int32Add_P2) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
// p0 + p1
BUILD(r, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -152,8 +141,7 @@
}
}
-
-TEST(Run_WasmFloat32Add) {
+WASM_EXEC_TEST(Float32Add) {
WasmRunner<int32_t> r;
// int(11.5f + 44.5f)
BUILD(r,
@@ -161,15 +149,13 @@
CHECK_EQ(56, r.Call());
}
-
-TEST(Run_WasmFloat64Add) {
+WASM_EXEC_TEST(Float64Add) {
WasmRunner<int32_t> r;
// return int(13.5d + 43.5d)
BUILD(r, WASM_I32_SCONVERT_F64(WASM_F64_ADD(WASM_F64(13.5), WASM_F64(43.5))));
CHECK_EQ(57, r.Call());
}
-
void TestInt32Binop(WasmOpcode opcode, int32_t expected, int32_t a, int32_t b) {
{
WasmRunner<int32_t> r;
@@ -185,7 +171,7 @@
}
}
-TEST(Run_WasmInt32Binops) {
+WASM_EXEC_TEST(Int32Binops) {
TestInt32Binop(kExprI32Add, 88888888, 33333333, 55555555);
TestInt32Binop(kExprI32Sub, -1111111, 7777777, 8888888);
TestInt32Binop(kExprI32Mul, 65130756, 88734, 734);
@@ -217,7 +203,6 @@
TestInt32Binop(kExprI32GeU, 1, 0xF0000000, 98978);
}
-
void TestInt32Unop(WasmOpcode opcode, int32_t expected, int32_t a) {
{
WasmRunner<int32_t> r;
@@ -233,8 +218,7 @@
}
}
-
-TEST(Run_WasmInt32Clz) {
+WASM_EXEC_TEST(Int32Clz) {
TestInt32Unop(kExprI32Clz, 0, 0x80001000);
TestInt32Unop(kExprI32Clz, 1, 0x40000500);
TestInt32Unop(kExprI32Clz, 2, 0x20000300);
@@ -270,8 +254,7 @@
TestInt32Unop(kExprI32Clz, 32, 0x00000000);
}
-
-TEST(Run_WasmInt32Ctz) {
+WASM_EXEC_TEST(Int32Ctz) {
TestInt32Unop(kExprI32Ctz, 32, 0x00000000);
TestInt32Unop(kExprI32Ctz, 31, 0x80000000);
TestInt32Unop(kExprI32Ctz, 30, 0x40000000);
@@ -307,8 +290,7 @@
TestInt32Unop(kExprI32Ctz, 0, 0x9afdbc81);
}
-
-TEST(Run_WasmInt32Popcnt) {
+WASM_EXEC_TEST(Int32Popcnt) {
TestInt32Unop(kExprI32Popcnt, 32, 0xffffffff);
TestInt32Unop(kExprI32Popcnt, 0, 0x00000000);
TestInt32Unop(kExprI32Popcnt, 1, 0x00008000);
@@ -316,7 +298,7 @@
TestInt32Unop(kExprI32Popcnt, 19, 0xfedcba09);
}
-TEST(Run_WasmI32Eqz) {
+WASM_EXEC_TEST(I32Eqz) {
TestInt32Unop(kExprI32Eqz, 0, 1);
TestInt32Unop(kExprI32Eqz, 0, -1);
TestInt32Unop(kExprI32Eqz, 0, -827343);
@@ -324,7 +306,7 @@
TestInt32Unop(kExprI32Eqz, 1, 0);
}
-TEST(Run_WasmI32Shl) {
+WASM_EXEC_TEST(I32Shl) {
WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
BUILD(r, WASM_I32_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -336,7 +318,7 @@
}
}
-TEST(Run_WasmI32Shr) {
+WASM_EXEC_TEST(I32Shr) {
WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
BUILD(r, WASM_I32_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -348,7 +330,7 @@
}
}
-TEST(Run_WasmI32Sar) {
+WASM_EXEC_TEST(I32Sar) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_I32_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -360,7 +342,7 @@
}
}
-TEST(Run_WASM_Int32DivS_trap) {
+WASM_EXEC_TEST(Int32DivS_trap) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
const int32_t kMin = std::numeric_limits<int32_t>::min();
@@ -371,8 +353,7 @@
CHECK_TRAP(r.Call(kMin, 0));
}
-
-TEST(Run_WASM_Int32RemS_trap) {
+WASM_EXEC_TEST(Int32RemS_trap) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
const int32_t kMin = std::numeric_limits<int32_t>::min();
@@ -383,8 +364,7 @@
CHECK_TRAP(r.Call(kMin, 0));
}
-
-TEST(Run_WASM_Int32DivU_trap) {
+WASM_EXEC_TEST(Int32DivU_trap) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
const int32_t kMin = std::numeric_limits<int32_t>::min();
@@ -395,8 +375,7 @@
CHECK_TRAP(r.Call(kMin, 0));
}
-
-TEST(Run_WASM_Int32RemU_trap) {
+WASM_EXEC_TEST(Int32RemU_trap) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_I32_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(17, r.Call(217, 100));
@@ -407,60 +386,7 @@
CHECK_EQ(kMin, r.Call(kMin, -1));
}
-TEST(Run_WASM_Int32DivS_asmjs) {
- TestingModule module;
- module.origin = kAsmJsOrigin;
- WasmRunner<int32_t> r(&module, MachineType::Int32(), MachineType::Int32());
- BUILD(r, WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
- const int32_t kMin = std::numeric_limits<int32_t>::min();
- CHECK_EQ(0, r.Call(0, 100));
- CHECK_EQ(0, r.Call(100, 0));
- CHECK_EQ(0, r.Call(-1001, 0));
- CHECK_EQ(kMin, r.Call(kMin, -1));
- CHECK_EQ(0, r.Call(kMin, 0));
-}
-
-TEST(Run_WASM_Int32RemS_asmjs) {
- TestingModule module;
- module.origin = kAsmJsOrigin;
- WasmRunner<int32_t> r(&module, MachineType::Int32(), MachineType::Int32());
- BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
- const int32_t kMin = std::numeric_limits<int32_t>::min();
- CHECK_EQ(33, r.Call(133, 100));
- CHECK_EQ(0, r.Call(kMin, -1));
- CHECK_EQ(0, r.Call(100, 0));
- CHECK_EQ(0, r.Call(-1001, 0));
- CHECK_EQ(0, r.Call(kMin, 0));
-}
-
-TEST(Run_WASM_Int32DivU_asmjs) {
- TestingModule module;
- module.origin = kAsmJsOrigin;
- WasmRunner<int32_t> r(&module, MachineType::Int32(), MachineType::Int32());
- BUILD(r, WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
- const int32_t kMin = std::numeric_limits<int32_t>::min();
- CHECK_EQ(0, r.Call(0, 100));
- CHECK_EQ(0, r.Call(kMin, -1));
- CHECK_EQ(0, r.Call(100, 0));
- CHECK_EQ(0, r.Call(-1001, 0));
- CHECK_EQ(0, r.Call(kMin, 0));
-}
-
-TEST(Run_WASM_Int32RemU_asmjs) {
- TestingModule module;
- module.origin = kAsmJsOrigin;
- WasmRunner<int32_t> r(&module, MachineType::Int32(), MachineType::Int32());
- BUILD(r, WASM_I32_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
- const int32_t kMin = std::numeric_limits<int32_t>::min();
- CHECK_EQ(17, r.Call(217, 100));
- CHECK_EQ(0, r.Call(100, 0));
- CHECK_EQ(0, r.Call(-1001, 0));
- CHECK_EQ(0, r.Call(kMin, 0));
- CHECK_EQ(kMin, r.Call(kMin, -1));
-}
-
-
-TEST(Run_WASM_Int32DivS_byzero_const) {
+WASM_EXEC_TEST(Int32DivS_byzero_const) {
for (int8_t denom = -2; denom < 8; denom++) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_I8(denom)));
@@ -474,8 +400,7 @@
}
}
-
-TEST(Run_WASM_Int32DivU_byzero_const) {
+WASM_EXEC_TEST(Int32DivU_byzero_const) {
for (uint32_t denom = 0xfffffffe; denom < 8; denom++) {
WasmRunner<uint32_t> r(MachineType::Uint32());
BUILD(r, WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_I32V_1(denom)));
@@ -490,8 +415,7 @@
}
}
-
-TEST(Run_WASM_Int32DivS_trap_effect) {
+WASM_EXEC_TEST(Int32DivS_trap_effect) {
TestingModule module;
module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module, MachineType::Int32(), MachineType::Int32());
@@ -525,7 +449,6 @@
}
}
-
void TestFloat32BinopWithConvert(WasmOpcode opcode, int32_t expected, float a,
float b) {
{
@@ -544,7 +467,6 @@
}
}
-
void TestFloat32UnopWithConvert(WasmOpcode opcode, int32_t expected, float a) {
{
WasmRunner<int32_t> r;
@@ -560,7 +482,6 @@
}
}
-
void TestFloat64Binop(WasmOpcode opcode, int32_t expected, double a, double b) {
{
WasmRunner<int32_t> r;
@@ -576,7 +497,6 @@
}
}
-
void TestFloat64BinopWithConvert(WasmOpcode opcode, int32_t expected, double a,
double b) {
{
@@ -594,7 +514,6 @@
}
}
-
void TestFloat64UnopWithConvert(WasmOpcode opcode, int32_t expected, double a) {
{
WasmRunner<int32_t> r;
@@ -610,7 +529,7 @@
}
}
-TEST(Run_WasmFloat32Binops) {
+WASM_EXEC_TEST(Float32Binops) {
TestFloat32Binop(kExprF32Eq, 1, 8.125f, 8.125f);
TestFloat32Binop(kExprF32Ne, 1, 8.125f, 8.127f);
TestFloat32Binop(kExprF32Lt, 1, -9.5f, -9.0f);
@@ -624,14 +543,14 @@
TestFloat32BinopWithConvert(kExprF32Div, 11, 22.1f, 2.0f);
}
-TEST(Run_WasmFloat32Unops) {
+WASM_EXEC_TEST(Float32Unops) {
TestFloat32UnopWithConvert(kExprF32Abs, 8, 8.125f);
TestFloat32UnopWithConvert(kExprF32Abs, 9, -9.125f);
TestFloat32UnopWithConvert(kExprF32Neg, -213, 213.125f);
TestFloat32UnopWithConvert(kExprF32Sqrt, 12, 144.4f);
}
-TEST(Run_WasmFloat64Binops) {
+WASM_EXEC_TEST(Float64Binops) {
TestFloat64Binop(kExprF64Eq, 1, 16.25, 16.25);
TestFloat64Binop(kExprF64Ne, 1, 16.25, 16.15);
TestFloat64Binop(kExprF64Lt, 1, -32.4, 11.7);
@@ -645,14 +564,14 @@
TestFloat64BinopWithConvert(kExprF64Div, -1111, -2222.3, 2);
}
-TEST(Run_WasmFloat64Unops) {
+WASM_EXEC_TEST(Float64Unops) {
TestFloat64UnopWithConvert(kExprF64Abs, 108, 108.125);
TestFloat64UnopWithConvert(kExprF64Abs, 209, -209.125);
TestFloat64UnopWithConvert(kExprF64Neg, -209, 209.125);
TestFloat64UnopWithConvert(kExprF64Sqrt, 13, 169.4);
}
-TEST(Run_WasmFloat32Neg) {
+WASM_EXEC_TEST(Float32Neg) {
WasmRunner<float> r(MachineType::Float32());
BUILD(r, WASM_F32_NEG(WASM_GET_LOCAL(0)));
@@ -662,8 +581,22 @@
}
}
+WASM_EXEC_TEST(Float32SubMinusZero) {
+ WasmRunner<float> r(MachineType::Float32());
+ BUILD(r, WASM_F32_SUB(WASM_F32(-0.0), WASM_GET_LOCAL(0)));
-TEST(Run_WasmFloat64Neg) {
+ CHECK_EQ(0x7fe00000, bit_cast<uint32_t>(r.Call(bit_cast<float>(0x7fa00000))));
+}
+
+WASM_EXEC_TEST(Float64SubMinusZero) {
+ WasmRunner<double> r(MachineType::Float64());
+ BUILD(r, WASM_F64_SUB(WASM_F64(-0.0), WASM_GET_LOCAL(0)));
+
+ CHECK_EQ(0x7ff8123456789abc,
+ bit_cast<uint64_t>(r.Call(bit_cast<double>(0x7ff0123456789abc))));
+}
+
+WASM_EXEC_TEST(Float64Neg) {
WasmRunner<double> r(MachineType::Float64());
BUILD(r, WASM_F64_NEG(WASM_GET_LOCAL(0)));
@@ -673,8 +606,7 @@
}
}
-
-TEST(Run_Wasm_IfElse_P) {
+WASM_EXEC_TEST(IfElse_P) {
WasmRunner<int32_t> r(MachineType::Int32());
// if (p0) return 11; else return 22;
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
@@ -686,8 +618,53 @@
}
}
+WASM_EXEC_TEST(If_empty1) {
+ WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
+ BUILD(r, WASM_GET_LOCAL(0), kExprIf, kExprEnd, WASM_GET_LOCAL(1));
+ FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i - 9, *i)); }
+}
-TEST(Run_Wasm_IfElse_Unreachable1) {
+WASM_EXEC_TEST(IfElse_empty1) {
+ WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
+ BUILD(r, WASM_GET_LOCAL(0), kExprIf, kExprElse, kExprEnd, WASM_GET_LOCAL(1));
+ FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i - 8, *i)); }
+}
+
+WASM_EXEC_TEST(IfElse_empty2) {
+ WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
+ BUILD(r, WASM_GET_LOCAL(0), kExprIf, WASM_ZERO, kExprElse, kExprEnd,
+ WASM_GET_LOCAL(1));
+ FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i - 7, *i)); }
+}
+
+WASM_EXEC_TEST(IfElse_empty3) {
+ WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
+ BUILD(r, WASM_GET_LOCAL(0), kExprIf, kExprElse, WASM_ZERO, kExprEnd,
+ WASM_GET_LOCAL(1));
+ FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i - 6, *i)); }
+}
+
+WASM_EXEC_TEST(If_chain) {
+ WasmRunner<int32_t> r(MachineType::Int32());
+ // if (p0) 13; if (p0) 14; 15
+ BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_I8(13)),
+ WASM_IF(WASM_GET_LOCAL(0), WASM_I8(14)), WASM_I8(15));
+ FOR_INT32_INPUTS(i) { CHECK_EQ(15, r.Call(*i)); }
+}
+
+WASM_EXEC_TEST(If_chain_set) {
+ WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ // if (p0) p1 = 73; if (p0) p1 = 74; p1
+ BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(1, WASM_I8(73))),
+ WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(1, WASM_I8(74))),
+ WASM_GET_LOCAL(1));
+ FOR_INT32_INPUTS(i) {
+ int32_t expected = *i ? 74 : *i;
+ CHECK_EQ(expected, r.Call(*i, *i));
+ }
+}
+
+WASM_EXEC_TEST(IfElse_Unreachable1) {
WasmRunner<int32_t> r;
// if (0) unreachable; else return 22;
BUILD(r, WASM_IF_ELSE(WASM_ZERO, // --
@@ -696,24 +673,21 @@
CHECK_EQ(27, r.Call());
}
-
-TEST(Run_Wasm_Return12) {
+WASM_EXEC_TEST(Return12) {
WasmRunner<int32_t> r;
BUILD(r, RET_I8(12));
CHECK_EQ(12, r.Call());
}
-
-TEST(Run_Wasm_Return17) {
+WASM_EXEC_TEST(Return17) {
WasmRunner<int32_t> r;
BUILD(r, B1(RET_I8(17)));
CHECK_EQ(17, r.Call());
}
-
-TEST(Run_Wasm_Return_I32) {
+WASM_EXEC_TEST(Return_I32) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, RET(WASM_GET_LOCAL(0)));
@@ -721,8 +695,7 @@
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
}
-
-TEST(Run_Wasm_Return_F32) {
+WASM_EXEC_TEST(Return_F32) {
WasmRunner<float> r(MachineType::Float32());
BUILD(r, RET(WASM_GET_LOCAL(0)));
@@ -738,8 +711,7 @@
}
}
-
-TEST(Run_Wasm_Return_F64) {
+WASM_EXEC_TEST(Return_F64) {
WasmRunner<double> r(MachineType::Float64());
BUILD(r, RET(WASM_GET_LOCAL(0)));
@@ -755,8 +727,7 @@
}
}
-
-TEST(Run_Wasm_Select) {
+WASM_EXEC_TEST(Select) {
WasmRunner<int32_t> r(MachineType::Int32());
// return select(11, 22, a);
BUILD(r, WASM_SELECT(WASM_I8(11), WASM_I8(22), WASM_GET_LOCAL(0)));
@@ -766,8 +737,7 @@
}
}
-
-TEST(Run_Wasm_Select_strict1) {
+WASM_EXEC_TEST(Select_strict1) {
WasmRunner<int32_t> r(MachineType::Int32());
// select(a=0, a=1, a=2); return a
BUILD(r, B2(WASM_SELECT(WASM_SET_LOCAL(0, WASM_I8(0)),
@@ -777,8 +747,7 @@
FOR_INT32_INPUTS(i) { CHECK_EQ(2, r.Call(*i)); }
}
-
-TEST(Run_Wasm_Select_strict2) {
+WASM_EXEC_TEST(Select_strict2) {
WasmRunner<int32_t> r(MachineType::Int32());
r.AllocateLocal(kAstI32);
r.AllocateLocal(kAstI32);
@@ -791,7 +760,7 @@
}
}
-TEST(Run_Wasm_Select_strict3) {
+WASM_EXEC_TEST(Select_strict3) {
WasmRunner<int32_t> r(MachineType::Int32());
r.AllocateLocal(kAstI32);
r.AllocateLocal(kAstI32);
@@ -805,8 +774,7 @@
}
}
-
-TEST(Run_Wasm_BrIf_strict) {
+WASM_EXEC_TEST(BrIf_strict) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(
r,
@@ -816,14 +784,14 @@
FOR_INT32_INPUTS(i) { CHECK_EQ(99, r.Call(*i)); }
}
-TEST(Run_Wasm_BrTable0a) {
+WASM_EXEC_TEST(BrTable0a) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(0))), WASM_I8(91)));
FOR_INT32_INPUTS(i) { CHECK_EQ(91, r.Call(*i)); }
}
-TEST(Run_Wasm_BrTable0b) {
+WASM_EXEC_TEST(BrTable0b) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 1, BR_TARGET(0), BR_TARGET(0))),
@@ -831,7 +799,7 @@
FOR_INT32_INPUTS(i) { CHECK_EQ(92, r.Call(*i)); }
}
-TEST(Run_Wasm_BrTable0c) {
+WASM_EXEC_TEST(BrTable0c) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(
r,
@@ -844,13 +812,13 @@
}
}
-TEST(Run_Wasm_BrTable1) {
+WASM_EXEC_TEST(BrTable1) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 0, BR_TARGET(0))), RET_I8(93));
FOR_INT32_INPUTS(i) { CHECK_EQ(93, r.Call(*i)); }
}
-TEST(Run_Wasm_BrTable_loop) {
+WASM_EXEC_TEST(BrTable_loop) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
B2(WASM_LOOP(1, WASM_BR_TABLE(WASM_INC_LOCAL_BY(0, 1), 2, BR_TARGET(2),
@@ -864,7 +832,7 @@
CHECK_EQ(98, r.Call(-100));
}
-TEST(Run_Wasm_BrTable_br) {
+WASM_EXEC_TEST(BrTable_br) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 1, BR_TARGET(1), BR_TARGET(0))),
@@ -876,7 +844,7 @@
CHECK_EQ(91, r.Call(3));
}
-TEST(Run_Wasm_BrTable_br2) {
+WASM_EXEC_TEST(BrTable_br2) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B2(B2(B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 3, BR_TARGET(1),
@@ -893,7 +861,7 @@
CHECK_EQ(85, r.Call(5));
}
-TEST(Run_Wasm_BrTable4) {
+WASM_EXEC_TEST(BrTable4) {
for (int i = 0; i < 4; i++) {
for (int t = 0; t < 4; t++) {
uint32_t cases[] = {0, 1, 2, 3};
@@ -920,7 +888,7 @@
}
}
-TEST(Run_Wasm_BrTable4x4) {
+WASM_EXEC_TEST(BrTable4x4) {
for (byte a = 0; a < 4; a++) {
for (byte b = 0; b < 4; b++) {
for (byte c = 0; c < 4; c++) {
@@ -953,7 +921,7 @@
}
}
-TEST(Run_Wasm_BrTable4_fallthru) {
+WASM_EXEC_TEST(BrTable4_fallthru) {
byte code[] = {
B2(B2(B2(B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 3, BR_TARGET(0),
BR_TARGET(1), BR_TARGET(2), BR_TARGET(3))),
@@ -979,7 +947,7 @@
CHECK_EQ(108, r.Call(4, 100));
}
-TEST(Run_Wasm_F32ReinterpretI32) {
+WASM_EXEC_TEST(F32ReinterpretI32) {
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module);
@@ -994,8 +962,7 @@
}
}
-
-TEST(Run_Wasm_I32ReinterpretF32) {
+WASM_EXEC_TEST(I32ReinterpretF32) {
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module, MachineType::Int32());
@@ -1012,8 +979,7 @@
}
}
-
-TEST(Run_Wasm_ReturnStore) {
+WASM_EXEC_TEST(ReturnStore) {
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module);
@@ -1028,8 +994,7 @@
}
}
-
-TEST(Run_Wasm_VoidReturn1) {
+WASM_EXEC_TEST(VoidReturn1) {
// We use a wrapper function because WasmRunner<void> does not exist.
// Build the test function.
@@ -1048,8 +1013,7 @@
CHECK_EQ(kExpected, result);
}
-
-TEST(Run_Wasm_VoidReturn2) {
+WASM_EXEC_TEST(VoidReturn2) {
// We use a wrapper function because WasmRunner<void> does not exist.
// Build the test function.
TestSignatures sigs;
@@ -1067,13 +1031,42 @@
CHECK_EQ(kExpected, result);
}
+WASM_EXEC_TEST(Block_empty) {
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r, kExprBlock, kExprEnd, WASM_GET_LOCAL(0));
+ FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
+}
-TEST(Run_Wasm_Block_If_P) {
+WASM_EXEC_TEST(Block_empty_br1) {
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r, B1(WASM_BR(0)), WASM_GET_LOCAL(0));
+ FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
+}
+
+WASM_EXEC_TEST(Block_empty_brif1) {
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r, B1(WASM_BR_IF(0, WASM_ZERO)), WASM_GET_LOCAL(0));
+ FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
+}
+
+WASM_EXEC_TEST(Block_empty_brif2) {
+ WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
+ BUILD(r, B1(WASM_BR_IF(0, WASM_GET_LOCAL(1))), WASM_GET_LOCAL(0));
+ FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i, *i + 1)); }
+}
+
+WASM_EXEC_TEST(Block_br2) {
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r, B1(WASM_BRV(0, WASM_GET_LOCAL(0))));
+ FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
+}
+
+WASM_EXEC_TEST(Block_If_P) {
WasmRunner<int32_t> r(MachineType::Int32());
// { if (p0) return 51; return 52; }
BUILD(r, B2( // --
WASM_IF(WASM_GET_LOCAL(0), // --
- WASM_BRV(0, WASM_I8(51))), // --
+ WASM_BRV(1, WASM_I8(51))), // --
WASM_I8(52))); // --
FOR_INT32_INPUTS(i) {
int32_t expected = *i ? 51 : 52;
@@ -1081,8 +1074,31 @@
}
}
+WASM_EXEC_TEST(Loop_empty) {
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r, kExprLoop, kExprEnd, WASM_GET_LOCAL(0));
+ FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
+}
-TEST(Run_Wasm_Block_BrIf_P) {
+WASM_EXEC_TEST(Loop_empty_br1) {
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r, WASM_LOOP(1, WASM_BR(1)), WASM_GET_LOCAL(0));
+ FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
+}
+
+WASM_EXEC_TEST(Loop_empty_brif1) {
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r, WASM_LOOP(1, WASM_BR_IF(1, WASM_ZERO)), WASM_GET_LOCAL(0));
+ FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
+}
+
+WASM_EXEC_TEST(Loop_empty_brif2) {
+ WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
+ BUILD(r, WASM_LOOP(1, WASM_BR_IF(1, WASM_GET_LOCAL(1))), WASM_GET_LOCAL(0));
+ FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i, *i + 1)); }
+}
+
+WASM_EXEC_TEST(Block_BrIf_P) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B2(WASM_BRV_IF(0, WASM_I8(51), WASM_GET_LOCAL(0)), WASM_I8(52)));
FOR_INT32_INPUTS(i) {
@@ -1091,8 +1107,7 @@
}
}
-
-TEST(Run_Wasm_Block_IfElse_P_assign) {
+WASM_EXEC_TEST(Block_IfElse_P_assign) {
WasmRunner<int32_t> r(MachineType::Int32());
// { if (p0) p0 = 71; else p0 = 72; return p0; }
BUILD(r, B2( // --
@@ -1106,8 +1121,7 @@
}
}
-
-TEST(Run_Wasm_Block_IfElse_P_return) {
+WASM_EXEC_TEST(Block_IfElse_P_return) {
WasmRunner<int32_t> r(MachineType::Int32());
// if (p0) return 81; else return 82;
BUILD(r, // --
@@ -1120,8 +1134,7 @@
}
}
-
-TEST(Run_Wasm_Block_If_P_assign) {
+WASM_EXEC_TEST(Block_If_P_assign) {
WasmRunner<int32_t> r(MachineType::Int32());
// { if (p0) p0 = 61; p0; }
BUILD(r, WASM_BLOCK(
@@ -1133,16 +1146,14 @@
}
}
-
-TEST(Run_Wasm_DanglingAssign) {
+WASM_EXEC_TEST(DanglingAssign) {
WasmRunner<int32_t> r(MachineType::Int32());
// { return 0; p0 = 0; }
BUILD(r, B2(RET_I8(99), WASM_SET_LOCAL(0, WASM_ZERO)));
CHECK_EQ(99, r.Call(1));
}
-
-TEST(Run_Wasm_ExprIf_P) {
+WASM_EXEC_TEST(ExprIf_P) {
WasmRunner<int32_t> r(MachineType::Int32());
// p0 ? 11 : 22;
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
@@ -1154,8 +1165,7 @@
}
}
-
-TEST(Run_Wasm_ExprIf_P_fallthru) {
+WASM_EXEC_TEST(ExprIf_P_fallthru) {
WasmRunner<int32_t> r(MachineType::Int32());
// p0 ? 11 : 22;
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
@@ -1167,14 +1177,13 @@
}
}
-
-TEST(Run_Wasm_CountDown) {
+WASM_EXEC_TEST(CountDown) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(
2, WASM_LOOP(
1, WASM_IF(WASM_GET_LOCAL(0),
- WASM_BRV(0, WASM_SET_LOCAL(
+ WASM_BRV(1, WASM_SET_LOCAL(
0, WASM_I32_SUB(WASM_GET_LOCAL(0),
WASM_I8(1)))))),
WASM_GET_LOCAL(0)));
@@ -1183,12 +1192,11 @@
CHECK_EQ(0, r.Call(100));
}
-
-TEST(Run_Wasm_CountDown_fallthru) {
+WASM_EXEC_TEST(CountDown_fallthru) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(
- 2, WASM_LOOP(3, WASM_IF(WASM_NOT(WASM_GET_LOCAL(0)), WASM_BREAK(0)),
+ 2, WASM_LOOP(3, WASM_IF(WASM_NOT(WASM_GET_LOCAL(0)), WASM_BREAK(1)),
WASM_SET_LOCAL(
0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(1))),
WASM_CONTINUE(0)),
@@ -1198,8 +1206,7 @@
CHECK_EQ(0, r.Call(100));
}
-
-TEST(Run_Wasm_WhileCountDown) {
+WASM_EXEC_TEST(WhileCountDown) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(
2, WASM_WHILE(WASM_GET_LOCAL(0),
@@ -1211,10 +1218,9 @@
CHECK_EQ(0, r.Call(100));
}
-
-TEST(Run_Wasm_Loop_if_break1) {
+WASM_EXEC_TEST(Loop_if_break1) {
WasmRunner<int32_t> r(MachineType::Int32());
- BUILD(r, B2(WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BREAK(0)),
+ BUILD(r, B2(WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BREAK(1)),
WASM_SET_LOCAL(0, WASM_I8(99))),
WASM_GET_LOCAL(0)));
CHECK_EQ(99, r.Call(0));
@@ -1223,8 +1229,7 @@
CHECK_EQ(-29, r.Call(-29));
}
-
-TEST(Run_Wasm_Loop_if_break2) {
+WASM_EXEC_TEST(Loop_if_break2) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B2(WASM_LOOP(2, WASM_BR_IF(1, WASM_GET_LOCAL(0)),
WASM_SET_LOCAL(0, WASM_I8(99))),
@@ -1235,8 +1240,7 @@
CHECK_EQ(-29, r.Call(-29));
}
-
-TEST(Run_Wasm_Loop_if_break_fallthru) {
+WASM_EXEC_TEST(Loop_if_break_fallthru) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B1(WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BREAK(1)),
WASM_SET_LOCAL(0, WASM_I8(93)))),
@@ -1247,8 +1251,25 @@
CHECK_EQ(-22, r.Call(-22));
}
+WASM_EXEC_TEST(IfBreak1) {
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_SEQ(WASM_BR(0), WASM_UNREACHABLE)),
+ WASM_I8(91));
+ CHECK_EQ(91, r.Call(0));
+ CHECK_EQ(91, r.Call(1));
+ CHECK_EQ(91, r.Call(-8734));
+}
-TEST(Run_Wasm_LoadMemI32) {
+WASM_EXEC_TEST(IfBreak2) {
+ WasmRunner<int32_t> r(MachineType::Int32());
+ BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_SEQ(WASM_BR(0), RET_I8(77))),
+ WASM_I8(81));
+ CHECK_EQ(81, r.Call(0));
+ CHECK_EQ(81, r.Call(1));
+ CHECK_EQ(81, r.Call(-8734));
+}
+
+WASM_EXEC_TEST(LoadMemI32) {
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module, MachineType::Int32());
@@ -1266,8 +1287,7 @@
CHECK_EQ(77777777, r.Call(0));
}
-
-TEST(Run_Wasm_LoadMemI32_oob) {
+WASM_EXEC_TEST(LoadMemI32_oob) {
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module, MachineType::Uint32());
@@ -1286,30 +1306,7 @@
}
}
-
-TEST(Run_Wasm_LoadMemI32_oob_asm) {
- TestingModule module;
- module.origin = kAsmJsOrigin;
- int32_t* memory = module.AddMemoryElems<int32_t>(8);
- WasmRunner<int32_t> r(&module, MachineType::Uint32());
- module.RandomizeMemory(1112);
-
- BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0)));
-
- memory[0] = 999999;
- CHECK_EQ(999999, r.Call(0u));
- // TODO(titzer): offset 29-31 should also be OOB.
- for (uint32_t offset = 32; offset < 40; offset++) {
- CHECK_EQ(0, r.Call(offset));
- }
-
- for (uint32_t offset = 0x80000000; offset < 0x80000010; offset++) {
- CHECK_EQ(0, r.Call(offset));
- }
-}
-
-
-TEST(Run_Wasm_LoadMem_offset_oob) {
+WASM_EXEC_TEST(LoadMem_offset_oob) {
TestingModule module;
module.AddMemoryElems<int32_t>(8);
@@ -1335,8 +1332,7 @@
}
}
-
-TEST(Run_Wasm_LoadMemI32_offset) {
+WASM_EXEC_TEST(LoadMemI32_offset) {
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(4);
WasmRunner<int32_t> r(&module, MachineType::Int32());
@@ -1361,10 +1357,9 @@
CHECK_EQ(44444444, r.Call(8));
}
-
#if !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
-TEST(Run_Wasm_LoadMemI32_const_oob_misaligned) {
+WASM_EXEC_TEST(LoadMemI32_const_oob_misaligned) {
const int kMemSize = 12;
// TODO(titzer): Fix misaligned accesses on MIPS and re-enable.
for (int offset = 0; offset < kMemSize + 5; offset++) {
@@ -1389,8 +1384,7 @@
#endif
-
-TEST(Run_Wasm_LoadMemI32_const_oob) {
+WASM_EXEC_TEST(LoadMemI32_const_oob) {
const int kMemSize = 24;
for (int offset = 0; offset < kMemSize + 5; offset += 4) {
for (int index = 0; index < kMemSize + 5; index += 4) {
@@ -1412,8 +1406,7 @@
}
}
-
-TEST(Run_Wasm_StoreMemI32_offset) {
+WASM_EXEC_TEST(StoreMemI32_offset) {
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(4);
WasmRunner<int32_t> r(&module, MachineType::Int32());
@@ -1436,8 +1429,7 @@
}
}
-
-TEST(Run_Wasm_StoreMem_offset_oob) {
+WASM_EXEC_TEST(StoreMem_offset_oob) {
TestingModule module;
byte* memory = module.AddMemoryElems<byte>(32);
@@ -1473,8 +1465,7 @@
}
}
-
-TEST(Run_Wasm_LoadMemI32_P) {
+WASM_EXEC_TEST(LoadMemI32_P) {
const int kNumElems = 8;
TestingModule module;
int32_t* memory = module.AddMemoryElems<int32_t>(kNumElems);
@@ -1488,8 +1479,7 @@
}
}
-
-TEST(Run_Wasm_MemI32_Sum) {
+WASM_EXEC_TEST(MemI32_Sum) {
const int kNumElems = 20;
TestingModule module;
uint32_t* memory = module.AddMemoryElems<uint32_t>(kNumElems);
@@ -1521,24 +1511,22 @@
}
}
-
-TEST(Run_Wasm_CheckMachIntsZero) {
+WASM_EXEC_TEST(CheckMachIntsZero) {
const int kNumElems = 55;
TestingModule module;
module.AddMemoryElems<uint32_t>(kNumElems);
WasmRunner<uint32_t> r(&module, MachineType::Int32());
- BUILD(r, kExprBlock, 2, kExprLoop, 1, kExprIf, kExprGetLocal, 0, kExprBr, 0,
- kExprIfElse, kExprI32LoadMem, ZERO_ALIGNMENT, ZERO_OFFSET,
- kExprGetLocal, 0, kExprBr, 2, kExprI8Const, 255, kExprSetLocal, 0,
- kExprI32Sub, kExprGetLocal, 0, kExprI8Const, 4, kExprI8Const, 0);
+ BUILD(r, kExprLoop, kExprGetLocal, 0, kExprIf, kExprGetLocal, 0,
+ kExprI32LoadMem, 0, 0, kExprIf, kExprI8Const, 255, kExprReturn, ARITY_1,
+ kExprEnd, kExprGetLocal, 0, kExprI8Const, 4, kExprI32Sub, kExprSetLocal,
+ 0, kExprBr, ARITY_1, DEPTH_0, kExprEnd, kExprEnd, kExprI8Const, 0);
module.BlankMemory();
CHECK_EQ(0, r.Call((kNumElems - 1) * 4));
}
-
-TEST(Run_Wasm_MemF32_Sum) {
+WASM_EXEC_TEST(MemF32_Sum) {
const int kSize = 5;
TestingModule module;
module.AddMemoryElems<float>(kSize);
@@ -1571,7 +1559,6 @@
CHECK_EQ(71256.0f, buffer[0]);
}
-
template <typename T>
T GenerateAndRunFold(WasmOpcode binop, T* buffer, size_t size,
LocalType astType, MachineType memType) {
@@ -1602,8 +1589,7 @@
return module.raw_mem_at<double>(0);
}
-
-TEST(Run_Wasm_MemF64_Mul) {
+WASM_EXEC_TEST(MemF64_Mul) {
const size_t kSize = 6;
double buffer[kSize] = {1, 2, 2, 2, 2, 2};
double result = GenerateAndRunFold<double>(kExprF64Mul, buffer, kSize,
@@ -1611,14 +1597,12 @@
CHECK_EQ(32, result);
}
-
TEST(Build_Wasm_Infinite_Loop) {
WasmRunner<int32_t> r(MachineType::Int32());
// Only build the graph and compile, don't run.
BUILD(r, WASM_INFINITE_LOOP);
}
-
TEST(Build_Wasm_Infinite_Loop_effect) {
TestingModule module;
module.AddMemoryElems<int8_t>(16);
@@ -1628,55 +1612,47 @@
BUILD(r, WASM_LOOP(1, WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO)));
}
-
-TEST(Run_Wasm_Unreachable0a) {
+WASM_EXEC_TEST(Unreachable0a) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B2(WASM_BRV(0, WASM_I8(9)), RET(WASM_GET_LOCAL(0))));
CHECK_EQ(9, r.Call(0));
CHECK_EQ(9, r.Call(1));
}
-
-TEST(Run_Wasm_Unreachable0b) {
+WASM_EXEC_TEST(Unreachable0b) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B2(WASM_BRV(0, WASM_I8(7)), WASM_UNREACHABLE));
CHECK_EQ(7, r.Call(0));
CHECK_EQ(7, r.Call(1));
}
-
TEST(Build_Wasm_Unreachable1) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_UNREACHABLE);
}
-
TEST(Build_Wasm_Unreachable2) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_UNREACHABLE, WASM_UNREACHABLE);
}
-
TEST(Build_Wasm_Unreachable3) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_UNREACHABLE, WASM_UNREACHABLE, WASM_UNREACHABLE);
}
-
TEST(Build_Wasm_UnreachableIf1) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_UNREACHABLE, WASM_IF(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)));
}
-
TEST(Build_Wasm_UnreachableIf2) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_UNREACHABLE,
WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_UNREACHABLE));
}
-
-TEST(Run_Wasm_Unreachable_Load) {
+WASM_EXEC_TEST(Unreachable_Load) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B2(WASM_BRV(0, WASM_GET_LOCAL(0)),
WASM_LOAD_MEM(MachineType::Int8(), WASM_GET_LOCAL(0))));
@@ -1684,25 +1660,22 @@
CHECK_EQ(21, r.Call(21));
}
-
-TEST(Run_Wasm_Infinite_Loop_not_taken1) {
+WASM_EXEC_TEST(Infinite_Loop_not_taken1) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B2(WASM_IF(WASM_GET_LOCAL(0), WASM_INFINITE_LOOP), WASM_I8(45)));
// Run the code, but don't go into the infinite loop.
CHECK_EQ(45, r.Call(0));
}
-
-TEST(Run_Wasm_Infinite_Loop_not_taken2) {
+WASM_EXEC_TEST(Infinite_Loop_not_taken2) {
WasmRunner<int32_t> r(MachineType::Int32());
- BUILD(r, B1(WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_I8(45)),
+ BUILD(r, B1(WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I8(45)),
WASM_INFINITE_LOOP)));
// Run the code, but don't go into the infinite loop.
CHECK_EQ(45, r.Call(1));
}
-
-TEST(Run_Wasm_Infinite_Loop_not_taken2_brif) {
+WASM_EXEC_TEST(Infinite_Loop_not_taken2_brif) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
B2(WASM_BRV_IF(0, WASM_I8(45), WASM_GET_LOCAL(0)), WASM_INFINITE_LOOP));
@@ -1710,10 +1683,7 @@
CHECK_EQ(45, r.Call(1));
}
-
static void TestBuildGraphForSimpleExpression(WasmOpcode opcode) {
- if (!WasmOpcodes::IsSupported(opcode)) return;
-
Isolate* isolate = CcTest::InitIsolateOnce();
Zone zone(isolate->allocator());
HandleScope scope(isolate);
@@ -1726,20 +1696,18 @@
FunctionSig* sig = WasmOpcodes::Signature(opcode);
if (sig->parameter_count() == 1) {
- byte code[] = {WASM_NO_LOCALS, static_cast<byte>(opcode), kExprGetLocal, 0};
- TestBuildingGraph(&zone, &jsgraph, nullptr, sig, code,
+ byte code[] = {WASM_NO_LOCALS, kExprGetLocal, 0, static_cast<byte>(opcode)};
+ TestBuildingGraph(&zone, &jsgraph, nullptr, sig, nullptr, code,
code + arraysize(code));
} else {
CHECK_EQ(2, sig->parameter_count());
- byte code[] = {WASM_NO_LOCALS, static_cast<byte>(opcode),
- kExprGetLocal, 0,
- kExprGetLocal, 1};
- TestBuildingGraph(&zone, &jsgraph, nullptr, sig, code,
+ byte code[] = {WASM_NO_LOCALS, kExprGetLocal, 0, kExprGetLocal, 1,
+ static_cast<byte>(opcode)};
+ TestBuildingGraph(&zone, &jsgraph, nullptr, sig, nullptr, code,
code + arraysize(code));
}
}
-
TEST(Build_Wasm_SimpleExprs) {
// Test that the decoder can build a graph for all supported simple expressions.
#define GRAPH_BUILD_TEST(name, opcode, sig) \
@@ -1750,8 +1718,7 @@
#undef GRAPH_BUILD_TEST
}
-
-TEST(Run_Wasm_Int32LoadInt8_signext) {
+WASM_EXEC_TEST(Int32LoadInt8_signext) {
TestingModule module;
const int kNumElems = 16;
int8_t* memory = module.AddMemoryElems<int8_t>(kNumElems);
@@ -1765,8 +1732,7 @@
}
}
-
-TEST(Run_Wasm_Int32LoadInt8_zeroext) {
+WASM_EXEC_TEST(Int32LoadInt8_zeroext) {
TestingModule module;
const int kNumElems = 16;
byte* memory = module.AddMemory(kNumElems);
@@ -1780,8 +1746,7 @@
}
}
-
-TEST(Run_Wasm_Int32LoadInt16_signext) {
+WASM_EXEC_TEST(Int32LoadInt16_signext) {
TestingModule module;
const int kNumBytes = 16;
byte* memory = module.AddMemory(kNumBytes);
@@ -1796,8 +1761,7 @@
}
}
-
-TEST(Run_Wasm_Int32LoadInt16_zeroext) {
+WASM_EXEC_TEST(Int32LoadInt16_zeroext) {
TestingModule module;
const int kNumBytes = 16;
byte* memory = module.AddMemory(kNumBytes);
@@ -1812,8 +1776,7 @@
}
}
-
-TEST(Run_WasmInt32Global) {
+WASM_EXEC_TEST(Int32Global) {
TestingModule module;
int32_t* global = module.AddGlobal<int32_t>(MachineType::Int32());
WasmRunner<int32_t> r(&module, MachineType::Int32());
@@ -1829,8 +1792,7 @@
}
}
-
-TEST(Run_WasmInt32Globals_DontAlias) {
+WASM_EXEC_TEST(Int32Globals_DontAlias) {
const int kNumGlobals = 3;
TestingModule module;
int32_t* globals[] = {module.AddGlobal<int32_t>(MachineType::Int32()),
@@ -1858,8 +1820,7 @@
}
}
-
-TEST(Run_WasmFloat32Global) {
+WASM_EXEC_TEST(Float32Global) {
TestingModule module;
float* global = module.AddGlobal<float>(MachineType::Float32());
WasmRunner<int32_t> r(&module, MachineType::Int32());
@@ -1877,8 +1838,7 @@
}
}
-
-TEST(Run_WasmFloat64Global) {
+WASM_EXEC_TEST(Float64Global) {
TestingModule module;
double* global = module.AddGlobal<double>(MachineType::Float64());
WasmRunner<int32_t> r(&module, MachineType::Int32());
@@ -1896,8 +1856,7 @@
}
}
-
-TEST(Run_WasmMixedGlobals) {
+WASM_EXEC_TEST(MixedGlobals) {
TestingModule module;
int32_t* unused = module.AddGlobal<int32_t>(MachineType::Int32());
byte* memory = module.AddMemory(32);
@@ -1951,8 +1910,7 @@
USE(unused);
}
-
-TEST(Run_WasmCallEmpty) {
+WASM_EXEC_TEST(CallEmpty) {
const int32_t kExpected = -414444;
// Build the target function.
TestSignatures sigs;
@@ -1969,8 +1927,7 @@
CHECK_EQ(kExpected, result);
}
-
-TEST(Run_WasmCallF32StackParameter) {
+WASM_EXEC_TEST(CallF32StackParameter) {
// Build the target function.
LocalType param_types[20];
for (int i = 0; i < 20; i++) param_types[i] = kAstF32;
@@ -1982,8 +1939,8 @@
// Build the calling function.
WasmRunner<float> r(&module);
- BUILD(r, WASM_CALL_FUNCTION(
- index, WASM_F32(1.0f), WASM_F32(2.0f), WASM_F32(4.0f),
+ BUILD(r, WASM_CALL_FUNCTIONN(
+ 19, index, WASM_F32(1.0f), WASM_F32(2.0f), WASM_F32(4.0f),
WASM_F32(8.0f), WASM_F32(16.0f), WASM_F32(32.0f),
WASM_F32(64.0f), WASM_F32(128.0f), WASM_F32(256.0f),
WASM_F32(1.5f), WASM_F32(2.5f), WASM_F32(4.5f), WASM_F32(8.5f),
@@ -1994,8 +1951,7 @@
CHECK_EQ(256.5f, result);
}
-
-TEST(Run_WasmCallF64StackParameter) {
+WASM_EXEC_TEST(CallF64StackParameter) {
// Build the target function.
LocalType param_types[20];
for (int i = 0; i < 20; i++) param_types[i] = kAstF64;
@@ -2007,19 +1963,19 @@
// Build the calling function.
WasmRunner<double> r(&module);
- BUILD(r, WASM_CALL_FUNCTION(index, WASM_F64(1.0), WASM_F64(2.0),
- WASM_F64(4.0), WASM_F64(8.0), WASM_F64(16.0),
- WASM_F64(32.0), WASM_F64(64.0), WASM_F64(128.0),
- WASM_F64(256.0), WASM_F64(1.5), WASM_F64(2.5),
- WASM_F64(4.5), WASM_F64(8.5), WASM_F64(16.5),
- WASM_F64(32.5), WASM_F64(64.5), WASM_F64(128.5),
- WASM_F64(256.5), WASM_F64(512.5)));
+ BUILD(r, WASM_CALL_FUNCTIONN(19, index, WASM_F64(1.0), WASM_F64(2.0),
+ WASM_F64(4.0), WASM_F64(8.0), WASM_F64(16.0),
+ WASM_F64(32.0), WASM_F64(64.0), WASM_F64(128.0),
+ WASM_F64(256.0), WASM_F64(1.5), WASM_F64(2.5),
+ WASM_F64(4.5), WASM_F64(8.5), WASM_F64(16.5),
+ WASM_F64(32.5), WASM_F64(64.5), WASM_F64(128.5),
+ WASM_F64(256.5), WASM_F64(512.5)));
float result = r.Call();
CHECK_EQ(256.5, result);
}
-TEST(Run_WasmCallVoid) {
+WASM_EXEC_TEST(CallVoid) {
const byte kMemOffset = 8;
const int32_t kElemNum = kMemOffset / sizeof(int32_t);
const int32_t kExpected = -414444;
@@ -2043,8 +1999,7 @@
CHECK_EQ(kExpected, module.raw_mem_start<int32_t>()[kElemNum]);
}
-
-TEST(Run_WasmCall_Int32Add) {
+WASM_EXEC_TEST(Call_Int32Add) {
// Build the target function.
TestSignatures sigs;
TestingModule module;
@@ -2054,7 +2009,7 @@
// Build the caller function.
WasmRunner<int32_t> r(&module, MachineType::Int32(), MachineType::Int32());
- BUILD(r, WASM_CALL_FUNCTION(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+ BUILD(r, WASM_CALL_FUNCTION2(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT32_INPUTS(i) {
FOR_INT32_INPUTS(j) {
@@ -2065,7 +2020,7 @@
}
}
-TEST(Run_WasmCall_Float32Sub) {
+WASM_EXEC_TEST(Call_Float32Sub) {
TestSignatures sigs;
TestingModule module;
WasmFunctionCompiler t(sigs.f_ff(), &module);
@@ -2076,15 +2031,14 @@
// Builder the caller function.
WasmRunner<float> r(&module, MachineType::Float32(), MachineType::Float32());
- BUILD(r, WASM_CALL_FUNCTION(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+ BUILD(r, WASM_CALL_FUNCTION2(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT32_INPUTS(i) {
FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i - *j, r.Call(*i, *j)); }
}
}
-
-TEST(Run_WasmCall_Float64Sub) {
+WASM_EXEC_TEST(Call_Float64Sub) {
TestingModule module;
double* memory = module.AddMemoryElems<double>(16);
WasmRunner<int32_t> r(&module);
@@ -2118,7 +2072,6 @@
for (size_t i = 0; i < sizeof(__buf); i++) vec.push_back(__buf[i]); \
} while (false)
-
static void Run_WasmMixedCall_N(int start) {
const int kExpected = 6333;
const int kElemSize = 8;
@@ -2165,23 +2118,30 @@
// Build the calling function.
// =========================================================================
WasmRunner<int32_t> r(&module);
-
std::vector<byte> code;
- ADD_CODE(code,
- static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(result, true)),
- ZERO_ALIGNMENT, ZERO_OFFSET);
- ADD_CODE(code, WASM_ZERO);
- ADD_CODE(code, kExprCallFunction, static_cast<byte>(index));
+ // Load the offset for the store.
+ ADD_CODE(code, WASM_ZERO);
+
+ // Load the arguments.
for (int i = 0; i < num_params; i++) {
int offset = (i + 1) * kElemSize;
ADD_CODE(code, WASM_LOAD_MEM(memtypes[i], WASM_I8(offset)));
}
+ // Call the selector function.
+ ADD_CODE(code, kExprCallFunction, static_cast<byte>(num_params),
+ static_cast<byte>(index));
+
+ // Store the result in memory.
+ ADD_CODE(code,
+ static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(result, true)),
+ ZERO_ALIGNMENT, ZERO_OFFSET);
+
+ // Return the expected value.
ADD_CODE(code, WASM_I32V_2(kExpected));
- size_t end = code.size();
- code.push_back(0);
- r.Build(&code[0], &code[end]);
+
+ r.Build(&code[0], &code[0] + code.size());
// Run the code.
for (int t = 0; t < 10; t++) {
@@ -2199,13 +2159,12 @@
}
}
+WASM_EXEC_TEST(MixedCall_0) { Run_WasmMixedCall_N(0); }
+WASM_EXEC_TEST(MixedCall_1) { Run_WasmMixedCall_N(1); }
+WASM_EXEC_TEST(MixedCall_2) { Run_WasmMixedCall_N(2); }
+WASM_EXEC_TEST(MixedCall_3) { Run_WasmMixedCall_N(3); }
-TEST(Run_WasmMixedCall_0) { Run_WasmMixedCall_N(0); }
-TEST(Run_WasmMixedCall_1) { Run_WasmMixedCall_N(1); }
-TEST(Run_WasmMixedCall_2) { Run_WasmMixedCall_N(2); }
-TEST(Run_WasmMixedCall_3) { Run_WasmMixedCall_N(3); }
-
-TEST(Run_Wasm_AddCall) {
+WASM_EXEC_TEST(AddCall) {
TestSignatures sigs;
TestingModule module;
WasmFunctionCompiler t1(sigs.i_ii(), &module);
@@ -2216,21 +2175,21 @@
byte local = r.AllocateLocal(kAstI32);
BUILD(r, B2(WASM_SET_LOCAL(local, WASM_I8(99)),
WASM_I32_ADD(
- WASM_CALL_FUNCTION(t1.function_index_, WASM_GET_LOCAL(0),
- WASM_GET_LOCAL(0)),
- WASM_CALL_FUNCTION(t1.function_index_, WASM_GET_LOCAL(1),
- WASM_GET_LOCAL(local)))));
+ WASM_CALL_FUNCTION2(t1.function_index_, WASM_GET_LOCAL(0),
+ WASM_GET_LOCAL(0)),
+ WASM_CALL_FUNCTION2(t1.function_index_, WASM_GET_LOCAL(1),
+ WASM_GET_LOCAL(local)))));
CHECK_EQ(198, r.Call(0));
CHECK_EQ(200, r.Call(1));
CHECK_EQ(100, r.Call(-49));
}
-TEST(Run_Wasm_CountDown_expr) {
+WASM_EXEC_TEST(CountDown_expr) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_LOOP(
3, WASM_IF(WASM_NOT(WASM_GET_LOCAL(0)),
- WASM_BREAKV(0, WASM_GET_LOCAL(0))),
+ WASM_BREAKV(1, WASM_GET_LOCAL(0))),
WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_I8(1))),
WASM_CONTINUE(0)));
CHECK_EQ(0, r.Call(1));
@@ -2238,51 +2197,46 @@
CHECK_EQ(0, r.Call(100));
}
-
-TEST(Run_Wasm_ExprBlock2a) {
+WASM_EXEC_TEST(ExprBlock2a) {
WasmRunner<int32_t> r(MachineType::Int32());
- BUILD(r, B2(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_I8(1))), WASM_I8(1)));
+ BUILD(r, B2(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I8(1))), WASM_I8(1)));
CHECK_EQ(1, r.Call(0));
CHECK_EQ(1, r.Call(1));
}
-
-TEST(Run_Wasm_ExprBlock2b) {
+WASM_EXEC_TEST(ExprBlock2b) {
WasmRunner<int32_t> r(MachineType::Int32());
- BUILD(r, B2(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_I8(1))), WASM_I8(2)));
+ BUILD(r, B2(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I8(1))), WASM_I8(2)));
CHECK_EQ(2, r.Call(0));
CHECK_EQ(1, r.Call(1));
}
-
-TEST(Run_Wasm_ExprBlock2c) {
+WASM_EXEC_TEST(ExprBlock2c) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B2(WASM_BRV_IF(0, WASM_I8(1), WASM_GET_LOCAL(0)), WASM_I8(1)));
CHECK_EQ(1, r.Call(0));
CHECK_EQ(1, r.Call(1));
}
-
-TEST(Run_Wasm_ExprBlock2d) {
+WASM_EXEC_TEST(ExprBlock2d) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B2(WASM_BRV_IF(0, WASM_I8(1), WASM_GET_LOCAL(0)), WASM_I8(2)));
CHECK_EQ(2, r.Call(0));
CHECK_EQ(1, r.Call(1));
}
-
-TEST(Run_Wasm_ExprBlock_ManualSwitch) {
+WASM_EXEC_TEST(ExprBlock_ManualSwitch) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, WASM_BLOCK(6, WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(1)),
- WASM_BRV(0, WASM_I8(11))),
+ WASM_BRV(1, WASM_I8(11))),
WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(2)),
- WASM_BRV(0, WASM_I8(12))),
+ WASM_BRV(1, WASM_I8(12))),
WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(3)),
- WASM_BRV(0, WASM_I8(13))),
+ WASM_BRV(1, WASM_I8(13))),
WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(4)),
- WASM_BRV(0, WASM_I8(14))),
+ WASM_BRV(1, WASM_I8(14))),
WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(5)),
- WASM_BRV(0, WASM_I8(15))),
+ WASM_BRV(1, WASM_I8(15))),
WASM_I8(99)));
CHECK_EQ(99, r.Call(0));
CHECK_EQ(11, r.Call(1));
@@ -2293,8 +2247,7 @@
CHECK_EQ(99, r.Call(6));
}
-
-TEST(Run_Wasm_ExprBlock_ManualSwitch_brif) {
+WASM_EXEC_TEST(ExprBlock_ManualSwitch_brif) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r,
WASM_BLOCK(6, WASM_BRV_IF(0, WASM_I8(11),
@@ -2317,8 +2270,7 @@
CHECK_EQ(99, r.Call(6));
}
-
-TEST(Run_Wasm_nested_ifs) {
+WASM_EXEC_TEST(nested_ifs) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_IF_ELSE(
@@ -2326,36 +2278,32 @@
WASM_IF_ELSE(WASM_GET_LOCAL(1), WASM_I8(11), WASM_I8(12)),
WASM_IF_ELSE(WASM_GET_LOCAL(1), WASM_I8(13), WASM_I8(14))));
-
CHECK_EQ(11, r.Call(1, 1));
CHECK_EQ(12, r.Call(1, 0));
CHECK_EQ(13, r.Call(0, 1));
CHECK_EQ(14, r.Call(0, 0));
}
-
-TEST(Run_Wasm_ExprBlock_if) {
+WASM_EXEC_TEST(ExprBlock_if) {
WasmRunner<int32_t> r(MachineType::Int32());
BUILD(r, B1(WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_I8(11)),
- WASM_BRV(0, WASM_I8(14)))));
+ WASM_BRV(1, WASM_I8(14)))));
CHECK_EQ(11, r.Call(1));
CHECK_EQ(14, r.Call(0));
}
-
-TEST(Run_Wasm_ExprBlock_nested_ifs) {
+WASM_EXEC_TEST(ExprBlock_nested_ifs) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_BLOCK(
1, WASM_IF_ELSE(
WASM_GET_LOCAL(0),
WASM_IF_ELSE(WASM_GET_LOCAL(1), WASM_BRV(0, WASM_I8(11)),
- WASM_BRV(0, WASM_I8(12))),
+ WASM_BRV(1, WASM_I8(12))),
WASM_IF_ELSE(WASM_GET_LOCAL(1), WASM_BRV(0, WASM_I8(13)),
- WASM_BRV(0, WASM_I8(14))))));
-
+ WASM_BRV(1, WASM_I8(14))))));
CHECK_EQ(11, r.Call(1, 1));
CHECK_EQ(12, r.Call(1, 0));
@@ -2363,18 +2311,16 @@
CHECK_EQ(14, r.Call(0, 0));
}
-
-TEST(Run_Wasm_ExprLoop_nested_ifs) {
+WASM_EXEC_TEST(ExprLoop_nested_ifs) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_LOOP(
1, WASM_IF_ELSE(
WASM_GET_LOCAL(0),
WASM_IF_ELSE(WASM_GET_LOCAL(1), WASM_BRV(1, WASM_I8(11)),
- WASM_BRV(1, WASM_I8(12))),
+ WASM_BRV(3, WASM_I8(12))),
WASM_IF_ELSE(WASM_GET_LOCAL(1), WASM_BRV(1, WASM_I8(13)),
- WASM_BRV(1, WASM_I8(14))))));
-
+ WASM_BRV(3, WASM_I8(14))))));
CHECK_EQ(11, r.Call(1, 1));
CHECK_EQ(12, r.Call(1, 0));
@@ -2382,8 +2328,7 @@
CHECK_EQ(14, r.Call(0, 0));
}
-
-TEST(Run_Wasm_SimpleCallIndirect) {
+WASM_EXEC_TEST(SimpleCallIndirect) {
TestSignatures sigs;
TestingModule module;
@@ -2407,15 +2352,14 @@
// Builder the caller function.
WasmRunner<int32_t> r(&module, MachineType::Int32());
- BUILD(r, WASM_CALL_INDIRECT(1, WASM_GET_LOCAL(0), WASM_I8(66), WASM_I8(22)));
+ BUILD(r, WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_I8(66), WASM_I8(22)));
CHECK_EQ(88, r.Call(0));
CHECK_EQ(44, r.Call(1));
CHECK_TRAP(r.Call(2));
}
-
-TEST(Run_Wasm_MultipleCallIndirect) {
+WASM_EXEC_TEST(MultipleCallIndirect) {
TestSignatures sigs;
TestingModule module;
@@ -2440,11 +2384,11 @@
// Builder the caller function.
WasmRunner<int32_t> r(&module, MachineType::Int32(), MachineType::Int32(),
MachineType::Int32());
- BUILD(r,
- WASM_I32_ADD(WASM_CALL_INDIRECT(1, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1),
- WASM_GET_LOCAL(2)),
- WASM_CALL_INDIRECT(1, WASM_GET_LOCAL(1), WASM_GET_LOCAL(2),
- WASM_GET_LOCAL(0))));
+ BUILD(r, WASM_I32_ADD(
+ WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1),
+ WASM_GET_LOCAL(2)),
+ WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(1), WASM_GET_LOCAL(2),
+ WASM_GET_LOCAL(0))));
CHECK_EQ(5, r.Call(0, 1, 2));
CHECK_EQ(19, r.Call(0, 1, 9));
@@ -2457,7 +2401,7 @@
CHECK_TRAP(r.Call(2, 1, 0));
}
-TEST(Run_Wasm_CallIndirect_NoTable) {
+WASM_EXEC_TEST(CallIndirect_NoTable) {
TestSignatures sigs;
TestingModule module;
@@ -2472,70 +2416,70 @@
// Builder the caller function.
WasmRunner<int32_t> r(&module, MachineType::Int32());
- BUILD(r, WASM_CALL_INDIRECT(1, WASM_GET_LOCAL(0), WASM_I8(66), WASM_I8(22)));
+ BUILD(r, WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_I8(66), WASM_I8(22)));
CHECK_TRAP(r.Call(0));
CHECK_TRAP(r.Call(1));
CHECK_TRAP(r.Call(2));
}
-TEST(Run_Wasm_F32Floor) {
+WASM_EXEC_TEST(F32Floor) {
WasmRunner<float> r(MachineType::Float32());
BUILD(r, WASM_F32_FLOOR(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(floorf(*i), r.Call(*i)); }
}
-TEST(Run_Wasm_F32Ceil) {
+WASM_EXEC_TEST(F32Ceil) {
WasmRunner<float> r(MachineType::Float32());
BUILD(r, WASM_F32_CEIL(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(ceilf(*i), r.Call(*i)); }
}
-TEST(Run_Wasm_F32Trunc) {
+WASM_EXEC_TEST(F32Trunc) {
WasmRunner<float> r(MachineType::Float32());
BUILD(r, WASM_F32_TRUNC(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(truncf(*i), r.Call(*i)); }
}
-TEST(Run_Wasm_F32NearestInt) {
+WASM_EXEC_TEST(F32NearestInt) {
WasmRunner<float> r(MachineType::Float32());
BUILD(r, WASM_F32_NEARESTINT(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(nearbyintf(*i), r.Call(*i)); }
}
-TEST(Run_Wasm_F64Floor) {
+WASM_EXEC_TEST(F64Floor) {
WasmRunner<double> r(MachineType::Float64());
BUILD(r, WASM_F64_FLOOR(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(floor(*i), r.Call(*i)); }
}
-TEST(Run_Wasm_F64Ceil) {
+WASM_EXEC_TEST(F64Ceil) {
WasmRunner<double> r(MachineType::Float64());
BUILD(r, WASM_F64_CEIL(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ceil(*i), r.Call(*i)); }
}
-TEST(Run_Wasm_F64Trunc) {
+WASM_EXEC_TEST(F64Trunc) {
WasmRunner<double> r(MachineType::Float64());
BUILD(r, WASM_F64_TRUNC(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(trunc(*i), r.Call(*i)); }
}
-TEST(Run_Wasm_F64NearestInt) {
+WASM_EXEC_TEST(F64NearestInt) {
WasmRunner<double> r(MachineType::Float64());
BUILD(r, WASM_F64_NEARESTINT(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(nearbyint(*i), r.Call(*i)); }
}
-TEST(Run_Wasm_F32Min) {
+WASM_EXEC_TEST(F32Min) {
WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
BUILD(r, WASM_F32_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2558,8 +2502,7 @@
}
}
-
-TEST(Run_Wasm_F64Min) {
+WASM_EXEC_TEST(F64Min) {
WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
BUILD(r, WASM_F64_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2582,8 +2525,7 @@
}
}
-
-TEST(Run_Wasm_F32Max) {
+WASM_EXEC_TEST(F32Max) {
WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
BUILD(r, WASM_F32_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2606,8 +2548,7 @@
}
}
-
-TEST(Run_Wasm_F64Max) {
+WASM_EXEC_TEST(F64Max) {
WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
BUILD(r, WASM_F64_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2630,11 +2571,10 @@
}
}
-// TODO(ahaas): Fix on arm and mips and reenable.
-#if !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_ARM64 && !V8_TARGET_ARCH_MIPS && \
- !V8_TARGET_ARCH_MIPS64
+// TODO(ahaas): Fix on mips and reenable.
+#if !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
-TEST(Run_Wasm_F32Min_Snan) {
+WASM_EXEC_TEST(F32Min_Snan) {
// Test that the instruction does not return a signalling NaN.
{
WasmRunner<float> r;
@@ -2650,7 +2590,7 @@
}
}
-TEST(Run_Wasm_F32Max_Snan) {
+WASM_EXEC_TEST(F32Max_Snan) {
// Test that the instruction does not return a signalling NaN.
{
WasmRunner<float> r;
@@ -2666,7 +2606,7 @@
}
}
-TEST(Run_Wasm_F64Min_Snan) {
+WASM_EXEC_TEST(F64Min_Snan) {
// Test that the instruction does not return a signalling NaN.
{
WasmRunner<double> r;
@@ -2682,7 +2622,7 @@
}
}
-TEST(Run_Wasm_F64Max_Snan) {
+WASM_EXEC_TEST(F64Max_Snan) {
// Test that the instruction does not return a signalling NaN.
{
WasmRunner<double> r;
@@ -2700,7 +2640,7 @@
#endif
-TEST(Run_Wasm_I32SConvertF32) {
+WASM_EXEC_TEST(I32SConvertF32) {
WasmRunner<int32_t> r(MachineType::Float32());
BUILD(r, WASM_I32_SCONVERT_F32(WASM_GET_LOCAL(0)));
@@ -2714,8 +2654,7 @@
}
}
-
-TEST(Run_Wasm_I32SConvertF64) {
+WASM_EXEC_TEST(I32SConvertF64) {
WasmRunner<int32_t> r(MachineType::Float64());
BUILD(r, WASM_I32_SCONVERT_F64(WASM_GET_LOCAL(0)));
@@ -2729,8 +2668,7 @@
}
}
-
-TEST(Run_Wasm_I32UConvertF32) {
+WASM_EXEC_TEST(I32UConvertF32) {
WasmRunner<uint32_t> r(MachineType::Float32());
BUILD(r, WASM_I32_UCONVERT_F32(WASM_GET_LOCAL(0)));
@@ -2743,8 +2681,7 @@
}
}
-
-TEST(Run_Wasm_I32UConvertF64) {
+WASM_EXEC_TEST(I32UConvertF64) {
WasmRunner<uint32_t> r(MachineType::Float64());
BUILD(r, WASM_I32_UCONVERT_F64(WASM_GET_LOCAL(0)));
@@ -2757,7 +2694,7 @@
}
}
-TEST(Run_Wasm_F64CopySign) {
+WASM_EXEC_TEST(F64CopySign) {
WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
BUILD(r, WASM_F64_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2766,8 +2703,7 @@
}
}
-
-TEST(Run_Wasm_F32CopySign) {
+WASM_EXEC_TEST(F32CopySign) {
WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
BUILD(r, WASM_F32_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2794,32 +2730,28 @@
WasmFunctionCompiler t(sig, &module);
std::vector<byte> code;
- ADD_CODE(code, kExprCallIndirect, 1);
ADD_CODE(code, kExprI8Const, 0);
for (byte p = 0; p < num_params; p++) {
ADD_CODE(code, kExprGetLocal, p);
}
+ ADD_CODE(code, kExprCallIndirect, static_cast<byte>(num_params), 1);
t.Build(&code[0], &code[0] + code.size());
t.Compile();
}
}
-
TEST(Compile_Wasm_CallIndirect_Many_i32) { CompileCallIndirectMany(kAstI32); }
-
#if WASM_64
TEST(Compile_Wasm_CallIndirect_Many_i64) { CompileCallIndirectMany(kAstI64); }
#endif
-
TEST(Compile_Wasm_CallIndirect_Many_f32) { CompileCallIndirectMany(kAstF32); }
-
TEST(Compile_Wasm_CallIndirect_Many_f64) { CompileCallIndirectMany(kAstF64); }
-TEST(Run_WASM_Int32RemS_dead) {
+WASM_EXEC_TEST(Int32RemS_dead) {
WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)), WASM_ZERO);
const int32_t kMin = std::numeric_limits<int32_t>::min();
diff --git a/test/cctest/wasm/test-wasm-function-name-table.cc b/test/cctest/wasm/test-wasm-function-name-table.cc
new file mode 100644
index 0000000..2f1e251
--- /dev/null
+++ b/test/cctest/wasm/test-wasm-function-name-table.cc
@@ -0,0 +1,110 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/wasm/wasm-function-name-table.h"
+#include "src/wasm/wasm-module.h"
+
+#include "test/cctest/cctest.h"
+
+using namespace v8::internal;
+using namespace v8::internal::wasm;
+
+namespace {
+
+#define CHECK_STREQ(exp, found) \
+ do { \
+ Vector<const char> exp_ = (exp); \
+ Vector<const char> found_ = (found); \
+ if (V8_UNLIKELY(exp_.length() != found_.length() || \
+ memcmp(exp_.start(), found_.start(), exp_.length()))) { \
+ V8_Fatal(__FILE__, __LINE__, \
+ "Check failed: (%s) != (%s) ('%.*s' vs '%.*s').", #exp, #found, \
+ exp_.length(), exp_.start(), found_.length(), found_.start()); \
+ } \
+ } while (0)
+
+void testFunctionNameTable(Vector<Vector<const char>> names) {
+ Isolate *isolate = CcTest::InitIsolateOnce();
+ HandleAndZoneScope scope;
+
+ WasmModule module;
+ std::vector<char> all_names;
+
+ uint32_t func_index = 0;
+ for (Vector<const char> name : names) {
+ size_t name_offset = all_names.size();
+ all_names.insert(all_names.end(), name.start(),
+ name.start() + name.length());
+ // Make every second function name null-terminated.
+ if (func_index % 2) all_names.push_back('\0');
+ module.functions.push_back(
+ {nullptr, 0, 0, static_cast<uint32_t>(name_offset),
+ static_cast<uint32_t>(name.length()), 0, 0, false});
+ ++func_index;
+ }
+
+ module.module_start = reinterpret_cast<byte *>(all_names.data());
+ module.module_end = module.module_start + all_names.size();
+
+ Handle<Object> wasm_function_name_table =
+ BuildFunctionNamesTable(isolate, &module);
+ CHECK(wasm_function_name_table->IsByteArray());
+
+ func_index = 0;
+ for (Vector<const char> name : names) {
+ Handle<Object> string_obj = GetWasmFunctionNameFromTable(
+ Handle<ByteArray>::cast(wasm_function_name_table), func_index);
+ CHECK(!string_obj.is_null());
+ CHECK(string_obj->IsString());
+ Handle<String> string = Handle<String>::cast(string_obj);
+ CHECK(string->IsUtf8EqualTo(name));
+ ++func_index;
+ }
+}
+
+void testFunctionNameTable(Vector<const char *> names) {
+ std::vector<Vector<const char>> names_vec;
+ for (const char *name : names) names_vec.push_back(CStrVector(name));
+ testFunctionNameTable(Vector<Vector<const char>>(
+ names_vec.data(), static_cast<int>(names_vec.size())));
+}
+
+} // namespace
+
+TEST(NoFunctions) { testFunctionNameTable(Vector<Vector<const char>>()); }
+
+TEST(OneFunctions) {
+ const char *names[] = {"foo"};
+ testFunctionNameTable(ArrayVector(names));
+}
+
+TEST(ThreeFunctions) {
+ const char *names[] = {"foo", "bar", "baz"};
+ testFunctionNameTable(ArrayVector(names));
+}
+
+TEST(OneUnnamedFunction) {
+ const char *names[] = {""};
+ testFunctionNameTable(ArrayVector(names));
+}
+
+TEST(UnnamedFirstFunction) {
+ const char *names[] = {"", "bar", "baz"};
+ testFunctionNameTable(ArrayVector(names));
+}
+
+TEST(UnnamedLastFunction) {
+ const char *names[] = {"bar", "baz", ""};
+ testFunctionNameTable(ArrayVector(names));
+}
+
+TEST(ThreeUnnamedFunctions) {
+ const char *names[] = {"", "", ""};
+ testFunctionNameTable(ArrayVector(names));
+}
+
+TEST(UTF8Names) {
+ const char *names[] = {"↱fun↰", "↺", "alpha:α beta:β"};
+ testFunctionNameTable(ArrayVector(names));
+}
diff --git a/test/cctest/wasm/test-wasm-stack.cc b/test/cctest/wasm/test-wasm-stack.cc
new file mode 100644
index 0000000..b6cd674
--- /dev/null
+++ b/test/cctest/wasm/test-wasm-stack.cc
@@ -0,0 +1,166 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/wasm/wasm-macro-gen.h"
+
+#include "test/cctest/cctest.h"
+#include "test/cctest/compiler/value-helper.h"
+#include "test/cctest/wasm/test-signatures.h"
+#include "test/cctest/wasm/wasm-run-utils.h"
+
+using namespace v8::base;
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+using namespace v8::internal::wasm;
+
+using v8::Local;
+using v8::Utils;
+
+namespace {
+
+#define CHECK_CSTREQ(exp, found) \
+ do { \
+ const char* exp_ = (exp); \
+ const char* found_ = (found); \
+ DCHECK_NOT_NULL(exp); \
+ if (V8_UNLIKELY(found_ == nullptr || strcmp(exp_, found_) != 0)) { \
+ V8_Fatal(__FILE__, __LINE__, \
+ "Check failed: (%s) != (%s) ('%s' vs '%s').", #exp, #found, \
+ exp_, found_ ? found_ : "<null>"); \
+ } \
+ } while (0)
+
+void PrintStackTrace(v8::Local<v8::StackTrace> stack) {
+ printf("Stack Trace (length %d):\n", stack->GetFrameCount());
+ for (int i = 0, e = stack->GetFrameCount(); i != e; ++i) {
+ v8::Local<v8::StackFrame> frame = stack->GetFrame(i);
+ v8::Local<v8::String> script = frame->GetScriptName();
+ v8::Local<v8::String> func = frame->GetFunctionName();
+ printf("[%d] (%s) %s:%d:%d\n", i,
+ script.IsEmpty() ? "<null>" : *v8::String::Utf8Value(script),
+ func.IsEmpty() ? "<null>" : *v8::String::Utf8Value(func),
+ frame->GetLineNumber(), frame->GetColumn());
+ }
+}
+
+struct ExceptionInfo {
+ const char* func_name;
+ int line_nr;
+ int column;
+};
+
+template <int N>
+void CheckExceptionInfos(Isolate* isolate, Handle<Object> exc,
+ const ExceptionInfo (&excInfos)[N]) {
+ // Check that it's indeed an Error object.
+ CHECK(Object::IsErrorObject(isolate, exc));
+
+ // Extract stack frame from the exception.
+ Local<v8::Value> localExc = Utils::ToLocal(exc);
+ v8::Local<v8::StackTrace> stack = v8::Exception::GetStackTrace(localExc);
+ PrintStackTrace(stack);
+ CHECK(!stack.IsEmpty());
+ CHECK_EQ(N, stack->GetFrameCount());
+
+ for (int frameNr = 0; frameNr < N; ++frameNr) {
+ v8::Local<v8::StackFrame> frame = stack->GetFrame(frameNr);
+ v8::String::Utf8Value funName(frame->GetFunctionName());
+ CHECK_CSTREQ(excInfos[frameNr].func_name, *funName);
+ CHECK_EQ(excInfos[frameNr].line_nr, frame->GetLineNumber());
+ CHECK_EQ(excInfos[frameNr].column, frame->GetColumn());
+ }
+}
+
+} // namespace
+
+// Call from JS to WASM to JS and throw an Error from JS.
+TEST(CollectDetailedWasmStack_ExplicitThrowFromJs) {
+ TestSignatures sigs;
+ TestingModule module;
+
+ // Initialize WasmFunctionCompiler first, since it sets up the HandleScope.
+ WasmFunctionCompiler comp1(sigs.v_v(), &module);
+
+ uint32_t js_throwing_index = module.AddJsFunction(
+ sigs.v_v(),
+ "(function js() {\n function a() {\n throw new Error(); };\n a(); })");
+
+ // Add a nop such that we don't always get position 1.
+ BUILD(comp1, WASM_NOP, WASM_CALL_FUNCTION0(js_throwing_index));
+ uint32_t wasm_index = comp1.CompileAndAdd();
+
+ WasmFunctionCompiler comp2(sigs.v_v(), &module);
+ BUILD(comp2, WASM_CALL_FUNCTION0(wasm_index));
+ uint32_t wasm_index_2 = comp2.CompileAndAdd();
+
+ Handle<JSFunction> js_wasm_wrapper = module.WrapCode(wasm_index_2);
+
+ Handle<JSFunction> js_trampoline = Handle<JSFunction>::cast(
+ v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+ CompileRun("(function callFn(fn) { fn(); })"))));
+
+ Isolate* isolate = js_wasm_wrapper->GetIsolate();
+ isolate->SetCaptureStackTraceForUncaughtExceptions(true, 10,
+ v8::StackTrace::kOverview);
+ Handle<Object> global(isolate->context()->global_object(), isolate);
+ MaybeHandle<Object> maybe_exc;
+ Handle<Object> args[] = {js_wasm_wrapper};
+ MaybeHandle<Object> returnObjMaybe =
+ Execution::TryCall(isolate, js_trampoline, global, 1, args, &maybe_exc);
+ CHECK(returnObjMaybe.is_null());
+
+ // Line number is 1-based, with 0 == kNoLineNumberInfo.
+ ExceptionInfo expected_exceptions[] = {
+ {"a", 3, 8}, // -
+ {"js", 4, 2}, // -
+ {"<WASM>", static_cast<int>(wasm_index), 2}, // -
+ {"<WASM>", static_cast<int>(wasm_index_2), 1}, // -
+ {"callFn", 1, 24} // -
+ };
+ CheckExceptionInfos(isolate, maybe_exc.ToHandleChecked(),
+ expected_exceptions);
+}
+
+// Trigger a trap in WASM, stack should be JS -> WASM -> WASM.
+TEST(CollectDetailedWasmStack_WasmError) {
+ TestSignatures sigs;
+ TestingModule module;
+
+ WasmFunctionCompiler comp1(sigs.i_v(), &module,
+ ArrayVector("exec_unreachable"));
+ // Set the execution context, such that a runtime error can be thrown.
+ comp1.SetModuleContext();
+ BUILD(comp1, WASM_UNREACHABLE);
+ uint32_t wasm_index = comp1.CompileAndAdd();
+
+ WasmFunctionCompiler comp2(sigs.i_v(), &module,
+ ArrayVector("call_exec_unreachable"));
+ BUILD(comp2, WASM_CALL_FUNCTION0(wasm_index));
+ uint32_t wasm_index_2 = comp2.CompileAndAdd();
+
+ Handle<JSFunction> js_wasm_wrapper = module.WrapCode(wasm_index_2);
+
+ Handle<JSFunction> js_trampoline = Handle<JSFunction>::cast(
+ v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+ CompileRun("(function callFn(fn) { fn(); })"))));
+
+ Isolate* isolate = js_wasm_wrapper->GetIsolate();
+ isolate->SetCaptureStackTraceForUncaughtExceptions(true, 10,
+ v8::StackTrace::kOverview);
+ Handle<Object> global(isolate->context()->global_object(), isolate);
+ MaybeHandle<Object> maybe_exc;
+ Handle<Object> args[] = {js_wasm_wrapper};
+ MaybeHandle<Object> maybe_return_obj =
+ Execution::TryCall(isolate, js_trampoline, global, 1, args, &maybe_exc);
+ CHECK(maybe_return_obj.is_null());
+
+ // Line number is 1-based, with 0 == kNoLineNumberInfo.
+ ExceptionInfo expected_exceptions[] = {
+ {"<WASM>", static_cast<int>(wasm_index), 1}, // -
+ {"<WASM>", static_cast<int>(wasm_index_2), 1}, // -
+ {"callFn", 1, 24} //-
+ };
+ CheckExceptionInfos(isolate, maybe_exc.ToHandleChecked(),
+ expected_exceptions);
+}
diff --git a/test/cctest/wasm/test-wasm-trap-position.cc b/test/cctest/wasm/test-wasm-trap-position.cc
new file mode 100644
index 0000000..13f2929
--- /dev/null
+++ b/test/cctest/wasm/test-wasm-trap-position.cc
@@ -0,0 +1,140 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/wasm/wasm-macro-gen.h"
+
+#include "test/cctest/cctest.h"
+#include "test/cctest/compiler/value-helper.h"
+#include "test/cctest/wasm/test-signatures.h"
+#include "test/cctest/wasm/wasm-run-utils.h"
+
+using namespace v8::base;
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+using namespace v8::internal::wasm;
+
+using v8::Local;
+using v8::Utils;
+
+namespace {
+
+#define CHECK_CSTREQ(exp, found) \
+ do { \
+ const char* exp_ = (exp); \
+ const char* found_ = (found); \
+ DCHECK_NOT_NULL(exp); \
+ if (V8_UNLIKELY(found_ == nullptr || strcmp(exp_, found_) != 0)) { \
+ V8_Fatal(__FILE__, __LINE__, \
+ "Check failed: (%s) != (%s) ('%s' vs '%s').", #exp, #found, \
+ exp_, found_ ? found_ : "<null>"); \
+ } \
+ } while (0)
+
+struct ExceptionInfo {
+ const char* func_name;
+ int line_nr;
+ int column;
+};
+
+template <int N>
+void CheckExceptionInfos(Isolate* isolate, Handle<Object> exc,
+ const ExceptionInfo (&excInfos)[N]) {
+ // Check that it's indeed an Error object.
+ CHECK(Object::IsErrorObject(isolate, exc));
+
+ // Extract stack frame from the exception.
+ Local<v8::Value> localExc = Utils::ToLocal(exc);
+ v8::Local<v8::StackTrace> stack = v8::Exception::GetStackTrace(localExc);
+ CHECK(!stack.IsEmpty());
+ CHECK_EQ(N, stack->GetFrameCount());
+
+ for (int frameNr = 0; frameNr < N; ++frameNr) {
+ v8::Local<v8::StackFrame> frame = stack->GetFrame(frameNr);
+ v8::String::Utf8Value funName(frame->GetFunctionName());
+ CHECK_CSTREQ(excInfos[frameNr].func_name, *funName);
+ CHECK_EQ(excInfos[frameNr].line_nr, frame->GetLineNumber());
+ CHECK_EQ(excInfos[frameNr].column, frame->GetColumn());
+ }
+}
+
+} // namespace
+
+// Trigger a trap for executing unreachable.
+TEST(Unreachable) {
+ TestSignatures sigs;
+ TestingModule module;
+
+ WasmFunctionCompiler comp1(sigs.v_v(), &module,
+ ArrayVector("exec_unreachable"));
+ // Set the execution context, such that a runtime error can be thrown.
+ comp1.SetModuleContext();
+ BUILD(comp1, WASM_UNREACHABLE);
+ uint32_t wasm_index = comp1.CompileAndAdd();
+
+ Handle<JSFunction> js_wasm_wrapper = module.WrapCode(wasm_index);
+
+ Handle<JSFunction> js_trampoline = Handle<JSFunction>::cast(
+ v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+ CompileRun("(function callFn(fn) { fn(); })"))));
+
+ Isolate* isolate = js_wasm_wrapper->GetIsolate();
+ isolate->SetCaptureStackTraceForUncaughtExceptions(true, 10,
+ v8::StackTrace::kOverview);
+ Handle<Object> global(isolate->context()->global_object(), isolate);
+ MaybeHandle<Object> maybe_exc;
+ Handle<Object> args[] = {js_wasm_wrapper};
+ MaybeHandle<Object> returnObjMaybe =
+ Execution::TryCall(isolate, js_trampoline, global, 1, args, &maybe_exc);
+ CHECK(returnObjMaybe.is_null());
+
+ ExceptionInfo expected_exceptions[] = {
+ {"<WASM>", static_cast<int>(wasm_index), 1}, // --
+ {"callFn", 1, 24} // --
+ };
+ CheckExceptionInfos(isolate, maybe_exc.ToHandleChecked(),
+ expected_exceptions);
+}
+
+// Trigger a trap for loading from out-of-bounds.
+TEST(IllegalLoad) {
+ TestSignatures sigs;
+ TestingModule module;
+
+ WasmFunctionCompiler comp1(sigs.v_v(), &module, ArrayVector("mem_oob"));
+ // Set the execution context, such that a runtime error can be thrown.
+ comp1.SetModuleContext();
+ BUILD(comp1, WASM_IF(WASM_ONE,
+ WASM_LOAD_MEM(MachineType::Int32(), WASM_I32V_1(-3))));
+ uint32_t wasm_index = comp1.CompileAndAdd();
+
+ WasmFunctionCompiler comp2(sigs.v_v(), &module, ArrayVector("call_mem_oob"));
+ // Insert a NOP such that the position of the call is not one.
+ BUILD(comp2, WASM_NOP, WASM_CALL_FUNCTION0(wasm_index));
+ uint32_t wasm_index_2 = comp2.CompileAndAdd();
+
+ Handle<JSFunction> js_wasm_wrapper = module.WrapCode(wasm_index_2);
+
+ Handle<JSFunction> js_trampoline = Handle<JSFunction>::cast(
+ v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+ CompileRun("(function callFn(fn) { fn(); })"))));
+
+ Isolate* isolate = js_wasm_wrapper->GetIsolate();
+ isolate->SetCaptureStackTraceForUncaughtExceptions(true, 10,
+ v8::StackTrace::kOverview);
+ Handle<Object> global(isolate->context()->global_object(), isolate);
+ MaybeHandle<Object> maybe_exc;
+ Handle<Object> args[] = {js_wasm_wrapper};
+ MaybeHandle<Object> returnObjMaybe =
+ Execution::TryCall(isolate, js_trampoline, global, 1, args, &maybe_exc);
+ CHECK(returnObjMaybe.is_null());
+
+ // Line number is 1-based, with 0 == kNoLineNumberInfo.
+ ExceptionInfo expected_exceptions[] = {
+ {"<WASM>", static_cast<int>(wasm_index), 6}, // --
+ {"<WASM>", static_cast<int>(wasm_index_2), 2}, // --
+ {"callFn", 1, 24} // --
+ };
+ CheckExceptionInfos(isolate, maybe_exc.ToHandleChecked(),
+ expected_exceptions);
+}
diff --git a/test/cctest/wasm/wasm-run-utils.h b/test/cctest/wasm/wasm-run-utils.h
index 1e85f46..a92c9ff 100644
--- a/test/cctest/wasm/wasm-run-utils.h
+++ b/test/cctest/wasm/wasm-run-utils.h
@@ -17,9 +17,11 @@
#include "src/compiler/node.h"
#include "src/compiler/pipeline.h"
#include "src/compiler/wasm-compiler.h"
+#include "src/compiler/zone-pool.h"
#include "src/wasm/ast-decoder.h"
#include "src/wasm/wasm-js.h"
+#include "src/wasm/wasm-macro-gen.h"
#include "src/wasm/wasm-module.h"
#include "src/wasm/wasm-opcodes.h"
@@ -159,20 +161,43 @@
rng.NextBytes(raw, end - raw);
}
- int AddFunction(FunctionSig* sig, Handle<Code> code) {
+ uint32_t AddFunction(FunctionSig* sig, Handle<Code> code) {
if (module->functions.size() == 0) {
// TODO(titzer): Reserving space here to avoid the underlying WasmFunction
// structs from moving.
module->functions.reserve(kMaxFunctions);
}
uint32_t index = static_cast<uint32_t>(module->functions.size());
- module->functions.push_back(
- {sig, index, 0, 0, 0, 0, 0, 0, 0, 0, 0, false, false});
+ module->functions.push_back({sig, index, 0, 0, 0, 0, 0, false});
instance->function_code.push_back(code);
DCHECK_LT(index, kMaxFunctions); // limited for testing.
return index;
}
+ uint32_t AddJsFunction(FunctionSig* sig, const char* source) {
+ Handle<JSFunction> jsfunc = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+ *v8::Local<v8::Function>::Cast(CompileRun(source))));
+ uint32_t index = AddFunction(sig, Handle<Code>::null());
+ Isolate* isolate = module->shared_isolate;
+ WasmName module_name = ArrayVector("test");
+ WasmName function_name;
+ Handle<Code> code = CompileWasmToJSWrapper(isolate, this, jsfunc, sig,
+ module_name, function_name);
+ instance->function_code[index] = code;
+ return index;
+ }
+
+ Handle<JSFunction> WrapCode(uint32_t index) {
+ Isolate* isolate = module->shared_isolate;
+ // Wrap the code so it can be called as a JS function.
+ Handle<String> name = isolate->factory()->NewStringFromStaticChars("main");
+ Handle<JSObject> module_object = Handle<JSObject>(0, isolate);
+ Handle<Code> code = instance->function_code[index];
+ WasmJs::InstallWasmFunctionMap(isolate, isolate->native_context());
+ return compiler::CompileJSToWasmWrapper(isolate, this, name, code,
+ module_object, index);
+ }
+
void SetFunctionCode(uint32_t index, Handle<Code> code) {
instance->function_code[index] = code;
}
@@ -218,9 +243,10 @@
};
inline void TestBuildingGraph(Zone* zone, JSGraph* jsgraph, ModuleEnv* module,
- FunctionSig* sig, const byte* start,
- const byte* end) {
- compiler::WasmGraphBuilder builder(zone, jsgraph, sig);
+ FunctionSig* sig,
+ SourcePositionTable* source_position_table,
+ const byte* start, const byte* end) {
+ compiler::WasmGraphBuilder builder(zone, jsgraph, sig, source_position_table);
TreeResult result =
BuildTFGraph(zone->allocator(), &builder, module, sig, start, end);
if (result.failed()) {
@@ -356,7 +382,7 @@
r.LowerGraph();
}
- CompilationInfo info("testing", isolate, graph()->zone());
+ CompilationInfo info(ArrayVector("testing"), isolate, graph()->zone());
code_ =
Pipeline::GenerateCodeForTesting(&info, descriptor, graph(), nullptr);
CHECK(!code_.is_null());
@@ -386,13 +412,18 @@
class WasmFunctionCompiler : public HandleAndZoneScope,
private GraphAndBuilders {
public:
- explicit WasmFunctionCompiler(FunctionSig* sig, TestingModule* module)
+ explicit WasmFunctionCompiler(
+ FunctionSig* sig, TestingModule* module,
+ Vector<const char> debug_name = ArrayVector("<WASM UNNAMED>"))
: GraphAndBuilders(main_zone()),
jsgraph(this->isolate(), this->graph(), this->common(), nullptr,
nullptr, this->machine()),
sig(sig),
descriptor_(nullptr),
- testing_module_(module) {
+ testing_module_(module),
+ debug_name_(debug_name),
+ local_decls(main_zone(), sig),
+ source_position_table_(this->graph()) {
if (module) {
// Get a new function from the testing module.
function_ = nullptr;
@@ -414,9 +445,11 @@
// The call descriptor is initialized when the function is compiled.
CallDescriptor* descriptor_;
TestingModule* testing_module_;
+ Vector<const char> debug_name_;
WasmFunction* function_;
int function_index_;
LocalDeclEncoder local_decls;
+ SourcePositionTable source_position_table_;
Isolate* isolate() { return main_isolate(); }
Graph* graph() const { return main_graph_; }
@@ -433,12 +466,13 @@
void Build(const byte* start, const byte* end) {
// Build the TurboFan graph.
local_decls.Prepend(&start, &end);
- TestBuildingGraph(main_zone(), &jsgraph, testing_module_, sig, start, end);
+ TestBuildingGraph(main_zone(), &jsgraph, testing_module_, sig,
+ &source_position_table_, start, end);
delete[] start;
}
byte AllocateLocal(LocalType type) {
- uint32_t index = local_decls.AddLocals(1, type, sig);
+ uint32_t index = local_decls.AddLocals(1, type);
byte result = static_cast<byte>(index);
DCHECK_EQ(index, result);
return result;
@@ -450,17 +484,34 @@
if (kPointerSize == 4) {
desc = testing_module_->GetI32WasmCallDescriptor(this->zone(), desc);
}
- CompilationInfo info("wasm compile", this->isolate(), this->zone());
- Handle<Code> result =
- Pipeline::GenerateCodeForTesting(&info, desc, this->graph());
+ CompilationInfo info(debug_name_, this->isolate(), this->zone(),
+ Code::ComputeFlags(Code::WASM_FUNCTION));
+ v8::base::SmartPointer<CompilationJob> job(Pipeline::NewWasmCompilationJob(
+ &info, graph(), desc, &source_position_table_));
+ if (job->OptimizeGraph() != CompilationJob::SUCCEEDED ||
+ job->GenerateCode() != CompilationJob::SUCCEEDED)
+ return Handle<Code>::null();
+
+ Handle<Code> code = info.code();
+
+ // Length is always 2, since usually <wasm_obj, func_index> is stored in the
+ // deopt data. Here, we only store the function index.
+ DCHECK(code->deoptimization_data() == nullptr ||
+ code->deoptimization_data()->length() == 0);
+ Handle<FixedArray> deopt_data =
+ isolate()->factory()->NewFixedArray(2, TENURED);
+ deopt_data->set(1, Smi::FromInt(function_index_));
+ deopt_data->set_length(2);
+ code->set_deoptimization_data(*deopt_data);
+
#ifdef ENABLE_DISASSEMBLER
- if (!result.is_null() && FLAG_print_opt_code) {
+ if (FLAG_print_opt_code) {
OFStream os(stdout);
- result->Disassemble("wasm code", os);
+ code->Disassemble("wasm code", os);
}
#endif
- return result;
+ return code;
}
uint32_t CompileAndAdd(uint16_t sig_index = 0) {
@@ -475,6 +526,16 @@
if (function_) return function_;
return &testing_module_->module->functions[function_index_];
}
+
+ // Set the context, such that e.g. runtime functions can be called.
+ void SetModuleContext() {
+ if (!testing_module_->instance->context.is_null()) {
+ CHECK(testing_module_->instance->context.is_identical_to(
+ main_isolate()->native_context()));
+ return;
+ }
+ testing_module_->instance->context = main_isolate()->native_context();
+ }
};
// A helper class to build graphs from Wasm bytecode, generate machine
@@ -597,6 +658,15 @@
}
};
+// A macro to define tests that run in different engine configurations.
+// Currently only supports compiled tests, but a future
+// RunWasmInterpreted_##name version will allow each test to also run in the
+// interpreter.
+#define WASM_EXEC_TEST(name) \
+ void RunWasm_##name(); \
+ TEST(RunWasmCompiled_##name) { RunWasm_##name(); } \
+ void RunWasm_##name()
+
} // namespace
#endif