Merge V8 5.3.332.45. DO NOT MERGE
Test: Manual
FPIIM-449
Change-Id: Id3254828b068abdea3cb10442e0172a8c9a98e03
(cherry picked from commit 13e2dadd00298019ed862f2b2fc5068bba730bcf)
diff --git a/test/BUILD.gn b/test/BUILD.gn
new file mode 100644
index 0000000..271df0d
--- /dev/null
+++ b/test/BUILD.gn
@@ -0,0 +1,203 @@
+# 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.
+
+import("../gni/isolate.gni")
+
+group("gn_all") {
+ testonly = true
+
+ deps = [
+ ":default_tests",
+ ]
+
+ if (host_os != "mac" || !is_android) {
+ # These items don't compile for Android on Mac.
+ deps += [
+ "cctest:cctest",
+ "cctest:generate-bytecode-expectations",
+ "unittests:unittests",
+ ]
+ }
+
+ if (v8_test_isolation_mode != "noop") {
+ deps += [
+ ":bot_default_run",
+ ":benchmarks_run",
+ ":default_run",
+ ":mozilla_run",
+ ":simdjs_run",
+ "test262:test262_run",
+ ]
+ }
+}
+
+###############################################################################
+# Test groups
+#
+
+group("default_tests") {
+ testonly = true
+
+ if (v8_test_isolation_mode != "noop") {
+ deps = [
+ ":cctest_run",
+ ":fuzzer_run",
+ ":intl_run",
+ ":message_run",
+ ":mjsunit_run",
+ ":preparser_run",
+ ":unittests_run",
+ ]
+ }
+}
+
+v8_isolate_run("bot_default") {
+ deps = [
+ ":default_tests",
+ ":webkit_run",
+ ]
+
+ isolate = "bot_default.isolate"
+}
+
+v8_isolate_run("default") {
+ deps = [
+ ":default_tests",
+ ]
+
+ isolate = "default.isolate"
+}
+
+v8_isolate_run("ignition") {
+ deps = [
+ ":cctest_run",
+ ":mjsunit_run",
+ ]
+
+ isolate = "ignition.isolate"
+}
+
+v8_isolate_run("optimize_for_size") {
+ deps = [
+ ":cctest_run",
+ ":intl_run",
+ ":mjsunit_run",
+ ":webkit_run",
+ ]
+
+ isolate = "optimize_for_size.isolate"
+}
+
+v8_isolate_run("perf") {
+ deps = [
+ ":cctest_exe_run",
+ "..:d8_run",
+ ]
+
+ isolate = "perf.isolate"
+}
+
+###############################################################################
+# Subtests
+#
+
+v8_isolate_run("benchmarks") {
+ deps = [
+ "..:d8_run",
+ ]
+
+ isolate = "benchmarks/benchmarks.isolate"
+}
+
+v8_isolate_run("cctest") {
+ deps = [
+ ":cctest_exe_run",
+ ]
+
+ isolate = "cctest/cctest.isolate"
+}
+
+v8_isolate_run("cctest_exe") {
+ deps = [
+ "cctest:cctest",
+ ]
+
+ isolate = "cctest/cctest_exe.isolate"
+}
+
+v8_isolate_run("fuzzer") {
+ deps = [
+ "..:v8_simple_json_fuzzer",
+ "..:v8_simple_parser_fuzzer",
+ "..:v8_simple_regexp_fuzzer",
+ "..:v8_simple_wasm_fuzzer",
+ "..:v8_simple_wasm_asmjs_fuzzer",
+ ]
+
+ isolate = "fuzzer/fuzzer.isolate"
+}
+
+v8_isolate_run("intl") {
+ deps = [
+ "..:d8_run",
+ ]
+
+ isolate = "intl/intl.isolate"
+}
+
+v8_isolate_run("message") {
+ deps = [
+ "..:d8_run",
+ ]
+
+ isolate = "message/message.isolate"
+}
+
+v8_isolate_run("mjsunit") {
+ deps = [
+ "..:d8_run",
+ ]
+
+ isolate = "mjsunit/mjsunit.isolate"
+}
+
+v8_isolate_run("mozilla") {
+ deps = [
+ "..:d8_run",
+ ]
+
+ isolate = "mozilla/mozilla.isolate"
+}
+
+v8_isolate_run("preparser") {
+ deps = [
+ "..:d8_run",
+ ]
+
+ isolate = "preparser/preparser.isolate"
+}
+
+v8_isolate_run("simdjs") {
+ deps = [
+ "..:d8_run",
+ ]
+
+ isolate = "simdjs/simdjs.isolate"
+}
+
+v8_isolate_run("unittests") {
+ deps = [
+ "unittests:unittests",
+ ]
+
+ isolate = "unittests/unittests.isolate"
+}
+
+v8_isolate_run("webkit") {
+ deps = [
+ "..:d8_run",
+ ]
+
+ isolate = "webkit/webkit.isolate"
+}
diff --git a/test/cctest/BUILD.gn b/test/cctest/BUILD.gn
new file mode 100644
index 0000000..38738b7
--- /dev/null
+++ b/test/cctest/BUILD.gn
@@ -0,0 +1,402 @@
+# 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.
+
+# Please keep this file in sync with cctest.gyp.
+
+import("../../gni/v8.gni")
+
+v8_executable("cctest") {
+ testonly = true
+
+ sources = [
+ "$target_gen_dir/resources.cc",
+ "cctest.cc",
+ "compiler/c-signature.h",
+ "compiler/code-assembler-tester.h",
+ "compiler/codegen-tester.cc",
+ "compiler/codegen-tester.h",
+ "compiler/function-tester.h",
+ "compiler/graph-builder-tester.h",
+ "compiler/test-basic-block-profiler.cc",
+ "compiler/test-branch-combine.cc",
+ "compiler/test-code-assembler.cc",
+ "compiler/test-gap-resolver.cc",
+ "compiler/test-graph-visualizer.cc",
+ "compiler/test-instruction.cc",
+ "compiler/test-js-constant-cache.cc",
+ "compiler/test-js-context-specialization.cc",
+ "compiler/test-js-typed-lowering.cc",
+ "compiler/test-jump-threading.cc",
+ "compiler/test-linkage.cc",
+ "compiler/test-loop-analysis.cc",
+ "compiler/test-loop-assignment-analysis.cc",
+ "compiler/test-machine-operator-reducer.cc",
+ "compiler/test-multiple-return.cc",
+ "compiler/test-node.cc",
+ "compiler/test-operator.cc",
+ "compiler/test-osr.cc",
+ "compiler/test-representation-change.cc",
+ "compiler/test-run-bytecode-graph-builder.cc",
+ "compiler/test-run-calls-to-external-references.cc",
+ "compiler/test-run-deopt.cc",
+ "compiler/test-run-inlining.cc",
+ "compiler/test-run-intrinsics.cc",
+ "compiler/test-run-jsbranches.cc",
+ "compiler/test-run-jscalls.cc",
+ "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",
+ "expression-type-collector.cc",
+ "expression-type-collector.h",
+ "gay-fixed.cc",
+ "gay-precision.cc",
+ "gay-shortest.cc",
+ "heap/heap-tester.h",
+ "heap/heap-utils.cc",
+ "heap/heap-utils.h",
+ "heap/test-alloc.cc",
+ "heap/test-array-buffer-tracker.cc",
+ "heap/test-compaction.cc",
+ "heap/test-heap.cc",
+ "heap/test-incremental-marking.cc",
+ "heap/test-lab.cc",
+ "heap/test-mark-compact.cc",
+ "heap/test-page-promotion.cc",
+ "heap/test-spaces.cc",
+ "interpreter/bytecode-expectations-printer.cc",
+ "interpreter/bytecode-expectations-printer.h",
+ "interpreter/interpreter-tester.cc",
+ "interpreter/source-position-matcher.cc",
+ "interpreter/source-position-matcher.h",
+ "interpreter/test-bytecode-generator.cc",
+ "interpreter/test-interpreter-intrinsics.cc",
+ "interpreter/test-interpreter.cc",
+ "interpreter/test-source-positions.cc",
+ "libsampler/test-sampler.cc",
+ "print-extension.cc",
+ "profiler-extension.cc",
+ "test-access-checks.cc",
+ "test-accessors.cc",
+ "test-api-accessors.cc",
+ "test-api-fast-accessor-builder.cc",
+ "test-api-interceptors.cc",
+ "test-api.cc",
+ "test-api.h",
+ "test-array-list.cc",
+ "test-asm-validator.cc",
+ "test-ast-expression-visitor.cc",
+ "test-ast.cc",
+ "test-atomicops.cc",
+ "test-bignum-dtoa.cc",
+ "test-bignum.cc",
+ "test-bit-vector.cc",
+ "test-circular-queue.cc",
+ "test-code-cache.cc",
+ "test-code-layout.cc",
+ "test-code-stub-assembler.cc",
+ "test-compiler.cc",
+ "test-constantpool.cc",
+ "test-conversions.cc",
+ "test-cpu-profiler.cc",
+ "test-date.cc",
+ "test-debug.cc",
+ "test-decls.cc",
+ "test-deoptimization.cc",
+ "test-dictionary.cc",
+ "test-diy-fp.cc",
+ "test-double.cc",
+ "test-dtoa.cc",
+ "test-eh-frame-hdr.cc",
+ "test-elements-kind.cc",
+ "test-fast-dtoa.cc",
+ "test-feedback-vector.cc",
+ "test-field-type-tracking.cc",
+ "test-fixed-dtoa.cc",
+ "test-flags.cc",
+ "test-func-name-inference.cc",
+ "test-global-handles.cc",
+ "test-global-object.cc",
+ "test-hashing.cc",
+ "test-hashmap.cc",
+ "test-heap-profiler.cc",
+ "test-hydrogen-types.cc",
+ "test-identity-map.cc",
+ "test-inobject-slack-tracking.cc",
+ "test-list.cc",
+ "test-liveedit.cc",
+ "test-lockers.cc",
+ "test-log.cc",
+ "test-mementos.cc",
+ "test-parsing.cc",
+ "test-platform.cc",
+ "test-profile-generator.cc",
+ "test-random-number-generator.cc",
+ "test-receiver-check-hidden-prototype.cc",
+ "test-regexp.cc",
+ "test-reloc-info.cc",
+ "test-representation.cc",
+ "test-sampler-api.cc",
+ "test-serialize.cc",
+ "test-simd.cc",
+ "test-strings.cc",
+ "test-strtod.cc",
+ "test-symbols.cc",
+ "test-thread-termination.cc",
+ "test-threads.cc",
+ "test-trace-event.cc",
+ "test-transitions.cc",
+ "test-typedarrays.cc",
+ "test-types.cc",
+ "test-unbound-queue.cc",
+ "test-unboxed-doubles.cc",
+ "test-unique.cc",
+ "test-unscopables-hidden-prototype.cc",
+ "test-usecounters.cc",
+ "test-utils.cc",
+ "test-version.cc",
+ "test-weakmaps.cc",
+ "test-weaksets.cc",
+ "trace-extension.cc",
+ "wasm/test-run-wasm-64.cc",
+ "wasm/test-run-wasm-asmjs.cc",
+ "wasm/test-run-wasm-interpreter.cc",
+ "wasm/test-run-wasm-js.cc",
+ "wasm/test-run-wasm-module.cc",
+ "wasm/test-run-wasm-relocation.cc",
+ "wasm/test-run-wasm.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",
+ ]
+
+ if (v8_target_cpu == "arm") {
+ sources += [
+ "test-assembler-arm.cc",
+ "test-code-stubs-arm.cc",
+ "test-code-stubs.cc",
+ "test-disasm-arm.cc",
+ "test-macro-assembler-arm.cc",
+ "test-run-wasm-relocation-arm.cc",
+ ]
+ } else if (v8_target_cpu == "arm64") {
+ sources += [
+ "test-assembler-arm64.cc",
+ "test-code-stubs-arm64.cc",
+ "test-code-stubs.cc",
+ "test-disasm-arm64.cc",
+ "test-fuzz-arm64.cc",
+ "test-javascript-arm64.cc",
+ "test-js-arm64-variables.cc",
+ "test-run-wasm-relocation-arm64.cc",
+ "test-utils-arm64.cc",
+ ]
+ } else if (v8_target_cpu == "x86") {
+ sources += [
+ "test-assembler-ia32.cc",
+ "test-code-stubs-ia32.cc",
+ "test-code-stubs.cc",
+ "test-disasm-ia32.cc",
+ "test-log-stack-tracer.cc",
+ "test-macro-assembler-ia32.cc",
+ "test-run-wasm-relocation-ia32.cc",
+ ]
+ } else if (v8_target_cpu == "mips") {
+ sources += [
+ "test-assembler-mips.cc",
+ "test-code-stubs-mips.cc",
+ "test-code-stubs.cc",
+ "test-disasm-mips.cc",
+ "test-macro-assembler-mips.cc",
+ ]
+ } else if (v8_target_cpu == "mipsel") {
+ sources += [
+ "test-assembler-mips.cc",
+ "test-code-stubs-mips.cc",
+ "test-code-stubs.cc",
+ "test-disasm-mips.cc",
+ "test-macro-assembler-mips.cc",
+ ]
+ } else if (v8_target_cpu == "mips64") {
+ sources += [
+ "test-assembler-mips64.cc",
+ "test-code-stubs-mips64.cc",
+ "test-code-stubs.cc",
+ "test-disasm-mips64.cc",
+ "test-macro-assembler-mips64.cc",
+ ]
+ } else if (v8_target_cpu == "mips64el") {
+ sources += [
+ "test-assembler-mips64.cc",
+ "test-code-stubs-mips64.cc",
+ "test-code-stubs.cc",
+ "test-disasm-mips64.cc",
+ "test-macro-assembler-mips64.cc",
+ ]
+ } else if (v8_target_cpu == "x64") {
+ sources += [
+ "test-assembler-x64.cc",
+ "test-code-stubs-x64.cc",
+ "test-code-stubs.cc",
+ "test-disasm-x64.cc",
+ "test-log-stack-tracer.cc",
+ "test-macro-assembler-x64.cc",
+ "test-run-wasm-relocation-x64.cc",
+ ]
+ } else if (v8_target_cpu == "x87") {
+ sources += [
+ "test-assembler-x87.cc",
+ "test-code-stubs-x87.cc",
+ "test-code-stubs.cc",
+ "test-disasm-x87.cc",
+ "test-log-stack-tracer.cc",
+ "test-macro-assembler-x87.cc",
+ "test-run-wasm-relocation-x87.cc",
+ ]
+ } else if (v8_target_cpu == "ppc" || v8_target_cpu == "ppc64") {
+ sources += [
+ "test-assembler-ppc.cc",
+ "test-code-stubs.cc",
+ "test-disasm-ppc.cc",
+ ]
+ } else if (v8_target_cpu == "s390" || v8_target_cpu == "s390x") {
+ sources += [
+ "test-assembler-s390.cc",
+ "test-code-stubs.cc",
+ "test-disasm-s390.cc",
+ ]
+ }
+
+ if (is_linux) {
+ # TODO(machenbach): Translate 'or OS=="qnx"' from gyp.
+ sources += [ "test-platform-linux.cc" ]
+ } else if (is_win) {
+ sources += [ "test-platform-win32.cc" ]
+ # TODO(machenbach): Translate from gyp.
+ # "msvs_settings": {
+ # "VCCLCompilerTool": {
+ # # MSVS wants this for gay-{precision,shortest}.cc.
+ # "AdditionalOptions": ["/bigobj"],
+ # },
+ # },
+ }
+
+ configs = [
+ "../..:external_config",
+ "../..:internal_config_base",
+ ]
+
+ # TODO(machenbach): Translate from gyp.
+ #['v8_target_cpu=="ppc" or v8_target_cpu=="ppc64" \
+ # or v8_target_cpu=="arm" or v8_target_cpu=="arm64" \
+ # or v8_target_cpu=="s390" or v8_target_cpu=="s390x"', {
+ # # disable fmadd/fmsub so that expected results match generated code in
+ # # RunFloat64MulAndFloat64Add1 and friends.
+ # 'cflags': ['-ffp-contract=off'],
+ #}],
+
+ # TODO(machenbach): Translate from gyp.
+ #["OS=="aix"", {
+ # "ldflags": [ "-Wl,-bbigtoc" ],
+ #}],
+
+ deps = [
+ ":resources",
+ "../..:v8_libplatform",
+ "//build/config/sanitizers:deps",
+ "//build/win:default_exe_manifest",
+ ]
+
+ if (is_component_build) {
+ # cctest can't be built against a shared library, so we
+ # need to depend on the underlying static target in that case.
+ deps += [ "../..:v8_maybe_snapshot" ]
+ } else {
+ deps += [ "../..:v8" ]
+ }
+
+ if (is_win) {
+ # This warning is benignly triggered by the U16 and U32 macros in
+ # bytecode-utils.h.
+ # C4309: 'static_cast': truncation of constant value
+ cflags = [ "/wd4309" ]
+
+ # Suppress warnings about importing locally defined symbols.
+ if (is_component_build) {
+ ldflags = [
+ "/ignore:4049",
+ "/ignore:4217",
+ ]
+ }
+ }
+}
+
+action("resources") {
+ visibility = [ ":*" ] # Only targets in this file can depend on this.
+
+ script = "../../tools/js2c.py"
+
+ # The script depends on this other script, this rule causes a rebuild if it
+ # changes.
+ inputs = [
+ "../../tools/jsmin.py",
+ ]
+
+ # NOSORT
+ sources = [
+ "../../tools/splaytree.js",
+ "../../tools/codemap.js",
+ "../../tools/csvparser.js",
+ "../../tools/consarray.js",
+ "../../tools/profile.js",
+ "../../tools/profile_view.js",
+ "../../tools/logreader.js",
+ "log-eq-of-logging-and-traversal.js",
+ ]
+
+ outputs = [
+ "$target_gen_dir/resources.cc",
+ ]
+
+ args = [
+ rebase_path("$target_gen_dir/resources.cc", root_build_dir),
+ "TEST",
+ ]
+ args += rebase_path(sources, root_build_dir)
+}
+
+v8_executable("generate-bytecode-expectations") {
+ sources = [
+ "interpreter/bytecode-expectations-printer.cc",
+ "interpreter/bytecode-expectations-printer.h",
+ "interpreter/generate-bytecode-expectations.cc",
+ ]
+
+ configs = [
+ "../..:external_config",
+ "../..:internal_config_base",
+ ]
+
+ deps = [
+ "../..:v8_libplatform",
+ "//build/config/sanitizers:deps",
+ "//build/win:default_exe_manifest",
+ ]
+
+ if (is_component_build) {
+ # Same as cctest, we need to depend on the underlying static target.
+ deps += [ "../..:v8_maybe_snapshot" ]
+ } else {
+ deps += [ "../..:v8" ]
+ }
+}
diff --git a/test/cctest/cctest.cc b/test/cctest/cctest.cc
index 5681f70..312001a 100644
--- a/test/cctest/cctest.cc
+++ b/test/cctest/cctest.cc
@@ -186,7 +186,7 @@
}
}
- v8::V8::InitializeICU();
+ v8::V8::InitializeICUDefaultLocation(argv[0]);
v8::Platform* platform = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(platform);
v8::internal::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
diff --git a/test/cctest/cctest.gyp b/test/cctest/cctest.gyp
index e33ee81..c71bc9f 100644
--- a/test/cctest/cctest.gyp
+++ b/test/cctest/cctest.gyp
@@ -25,6 +25,8 @@
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# Please keep this file in sync with BUILD.gn.
+
{
'variables': {
'v8_code': 1,
@@ -47,13 +49,14 @@
'compiler/c-signature.h',
'compiler/codegen-tester.cc',
'compiler/codegen-tester.h',
+ 'compiler/code-assembler-tester.h',
'compiler/function-tester.h',
'compiler/graph-builder-tester.h',
'compiler/test-basic-block-profiler.cc',
'compiler/test-branch-combine.cc',
- 'compiler/test-code-stub-assembler.cc',
'compiler/test-gap-resolver.cc',
'compiler/test-graph-visualizer.cc',
+ 'compiler/test-code-assembler.cc',
'compiler/test-instruction.cc',
'compiler/test-js-context-specialization.cc',
'compiler/test-js-constant-cache.cc',
@@ -90,25 +93,33 @@
'expression-type-collector.cc',
'expression-type-collector.h',
'interpreter/interpreter-tester.cc',
+ 'interpreter/source-position-matcher.cc',
+ 'interpreter/source-position-matcher.h',
'interpreter/test-bytecode-generator.cc',
'interpreter/test-interpreter.cc',
'interpreter/test-interpreter-intrinsics.cc',
+ 'interpreter/test-source-positions.cc',
'interpreter/bytecode-expectations-printer.cc',
'interpreter/bytecode-expectations-printer.h',
'gay-fixed.cc',
'gay-precision.cc',
'gay-shortest.cc',
'heap/heap-tester.h',
+ 'heap/heap-utils.cc',
+ 'heap/heap-utils.h',
'heap/test-alloc.cc',
+ 'heap/test-array-buffer-tracker.cc',
'heap/test-compaction.cc',
'heap/test-heap.cc',
'heap/test-incremental-marking.cc',
'heap/test-lab.cc',
'heap/test-mark-compact.cc',
+ 'heap/test-page-promotion.cc',
'heap/test-spaces.cc',
- 'heap/utils-inl.h',
+ 'libsampler/test-sampler.cc',
'print-extension.cc',
'profiler-extension.cc',
+ 'test-access-checks.cc',
'test-accessors.cc',
'test-api.cc',
'test-api.h',
@@ -124,6 +135,9 @@
'test-bignum-dtoa.cc',
'test-bit-vector.cc',
'test-circular-queue.cc',
+ 'test-code-cache.cc',
+ 'test-code-layout.cc',
+ 'test-code-stub-assembler.cc',
'test-compiler.cc',
'test-constantpool.cc',
'test-conversions.cc',
@@ -137,6 +151,7 @@
'test-double.cc',
'test-dtoa.cc',
'test-elements-kind.cc',
+ 'test-eh-frame-hdr.cc',
'test-fast-dtoa.cc',
'test-feedback-vector.cc',
'test-field-type-tracking.cc',
@@ -180,6 +195,7 @@
'test-unboxed-doubles.cc',
'test-unique.cc',
'test-unscopables-hidden-prototype.cc',
+ 'test-usecounters.cc',
'test-utils.cc',
'test-version.cc',
'test-weakmaps.cc',
@@ -188,10 +204,12 @@
'wasm/test-run-wasm.cc',
'wasm/test-run-wasm-64.cc',
'wasm/test-run-wasm-asmjs.cc',
+ 'wasm/test-run-wasm-interpreter.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-run-wasm-relocation.cc',
'wasm/test-wasm-stack.cc',
'wasm/test-wasm-trap-position.cc',
'wasm/wasm-run-utils.h',
diff --git a/test/cctest/cctest.status b/test/cctest/cctest.status
index e1da00d..a669a83 100644
--- a/test/cctest/cctest.status
+++ b/test/cctest/cctest.status
@@ -150,6 +150,7 @@
# TODO(mythria,4780): Related to type feedback support for calls.
'test-feedback-vector/VectorCallICStates': [PASS, NO_IGNITION],
+ 'test-feedback-vector/VectorCallCounts': [PASS, NO_IGNITION],
'test-compiler/FeedbackVectorPreservedAcrossRecompiles': [PASS, NO_IGNITION],
'test-heap/WeakFunctionInConstructor': [PASS, NO_IGNITION],
'test-heap/IncrementalMarkingClearsMonomorphicConstructor': [PASS, NO_IGNITION],
@@ -176,8 +177,8 @@
'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]],
+ # BUG(4751). Flaky with ignition.
+ 'test-cpu-profiler/JsNativeJsSample': [PASS, NO_IGNITION],
}], # ALWAYS
##############################################################################
@@ -303,10 +304,14 @@
'test-run-wasm-module/Run_WasmModule_CheckMemoryIsZero': [SKIP],
'test-run-wasm-module/Run_WasmModule_Global': [SKIP],
'test-run-wasm/RunWasmCompiled_Int32LoadInt16_signext': [SKIP],
+ 'test-run-wasm/RunWasmInterpreted_Int32LoadInt16_signext': [SKIP],
'test-run-wasm/RunWasmCompiled_Int32LoadInt16_zeroext': [SKIP],
+ 'test-run-wasm/RunWasmInterpreted_Int32LoadInt16_zeroext': [SKIP],
'test-run-wasm/RunWasmCompiled_MixedGlobals': [SKIP],
+ 'test-run-wasm/RunWasmInterpreted_MixedGlobals': [SKIP],
'test-run-wasm-64/RunWasmCompiled_I64*': [SKIP],
'test-run-wasm-64/RunWasmCompiled_LoadStoreI64_sx': [SKIP],
+ 'test-run-wasm-64/RunWasmInterpreted_LoadStoreI64_sx': [SKIP],
'test-run-wasm-64/Run_TestI64WasmRunner': [SKIP],
'test-run-wasm-64/RunWasmCompiled_Call_Int64Sub': [SKIP],
'test-run-wasm-64/RunWasmCompiled_MemI64_Sum': [SKIP],
@@ -386,7 +391,12 @@
'test-run-machops/RunFloat64MulAndFloat64Add2': [SKIP],
'test-run-machops/RunFloat64MulAndFloat64Sub1': [SKIP],
'test-run-machops/RunFloat64MulAndFloat64Sub2': [SKIP],
+ 'test-run-machops/RunFloat64Sin': [SKIP],
+ 'test-run-machops/RunFloat64Cos': [SKIP],
+ 'test-run-machops/RunFloat64Expm1': [SKIP],
+ 'test-run-machops/RunFloat64Tan': [SKIP],
'test-cpu-profiler/Inlining': [SKIP],
+ 'test-gap-resolver/FuzzResolver': [SKIP],
}], # 'arch == x87'
##############################################################################
@@ -541,10 +551,6 @@
'test-heap/TestCodeFlushingIncremental': [FAIL],
'test-heap/TestCodeFlushingIncrementalAbort': [PASS, ['mode == debug or dcheck_always_on == True', FAIL]],
- # TODO(rmcilroy,4766): Requires BytecodeGraphBuilder to track source position
- # on nodes (behind --turbo_source_positions flag).
- 'test-cpu-profiler/TickLinesOptimized': [FAIL],
-
# 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.
@@ -552,6 +558,7 @@
# TODO(mythria,4780): Related to type feedback support for calls.
'test-feedback-vector/VectorCallICStates': [FAIL],
+ 'test-feedback-vector/VectorCallCounts': [FAIL],
'test-compiler/FeedbackVectorPreservedAcrossRecompiles': [FAIL],
'test-heap/WeakFunctionInConstructor': [FAIL],
'test-heap/IncrementalMarkingClearsMonomorphicConstructor': [FAIL],
@@ -574,34 +581,8 @@
# 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],
- 'test-run-inlining/InlineSurplusArgumentsDeopt': [FAIL],
- 'test-run-inlining/InlineTwice': [FAIL],
- 'test-run-inlining/InlineSurplusArgumentsObject': [FAIL],
- 'test-run-inlining/InlineTwiceDependentDiamond': [FAIL],
- 'test-run-inlining/InlineWithArguments': [FAIL],
- 'test-run-inlining/InlineLoopUnguardedTwice': [FAIL],
- 'test-run-inlining/InlineOmitArgumentsObject': [FAIL],
- 'test-run-inlining/InlineLoopUnguardedOnce': [FAIL],
- 'test-run-inlining/InlineOmitArgumentsDeopt': [FAIL],
- 'test-run-inlining/InlineTwiceDependentDiamondDifferent': [FAIL],
- 'test-run-inlining/SimpleInliningContext': [FAIL],
- 'test-run-inlining/InlineMutuallyRecursive': [FAIL],
- 'test-run-inlining/InlineLoopGuardedEmpty': [FAIL],
- 'test-run-inlining/InlineLoopGuardedOnce': [FAIL],
- 'test-run-inlining/InlineOmitArguments': [FAIL],
- 'test-run-inlining/SimpleInlining': [FAIL],
- 'test-run-inlining/InlineLoopUnguardedEmpty': [FAIL],
- 'test-run-inlining/InlineNestedBuiltin': [FAIL],
- 'test-run-inlining/InlineSurplusArguments': [FAIL],
- 'test-run-inlining/InlineBuiltin': [FAIL],
- 'test-run-inlining/InlineTwiceDependent': [FAIL],
- 'test-run-inlining/SimpleInliningContextDeopt': [FAIL],
-
- # BUG(4751). Flaky with ignition and tsan.
- 'test-cpu-profiler/JsNativeJsSample': [PASS, ['tsan', SKIP]],
+ # BUG(4751). Flaky with Ignition.
+ 'test-cpu-profiler/JsNativeJsSample': [SKIP],
}], # ignition or ignition_turbofan
]
diff --git a/test/cctest/compiler/code-assembler-tester.h b/test/cctest/compiler/code-assembler-tester.h
new file mode 100644
index 0000000..609a137
--- /dev/null
+++ b/test/cctest/compiler/code-assembler-tester.h
@@ -0,0 +1,67 @@
+// 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/handles.h"
+#include "src/interface-descriptors.h"
+#include "src/isolate.h"
+#include "test/cctest/compiler/function-tester.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class ZoneHolder {
+ public:
+ explicit ZoneHolder(Isolate* isolate) : zone_(isolate->allocator()) {}
+ Zone* zone() { return &zone_; }
+
+ private:
+ Zone zone_;
+};
+
+// Inherit from ZoneHolder in order to create a zone that can be passed to
+// CodeAssembler base class constructor.
+template <typename CodeAssemblerT>
+class CodeAssemblerTesterImpl : private ZoneHolder, public CodeAssemblerT {
+ public:
+ // Test generating code for a stub.
+ CodeAssemblerTesterImpl(Isolate* isolate,
+ const CallInterfaceDescriptor& descriptor)
+ : ZoneHolder(isolate),
+ CodeAssemblerT(isolate, ZoneHolder::zone(), descriptor,
+ Code::ComputeFlags(Code::STUB), "test"),
+ scope_(isolate) {}
+
+ // Test generating code for a JS function (e.g. builtins).
+ CodeAssemblerTesterImpl(Isolate* isolate, int parameter_count)
+ : ZoneHolder(isolate),
+ CodeAssemblerT(isolate, ZoneHolder::zone(), parameter_count,
+ Code::ComputeFlags(Code::FUNCTION), "test"),
+ scope_(isolate) {}
+
+ // This constructor is intended to be used for creating code objects with
+ // specific flags.
+ CodeAssemblerTesterImpl(Isolate* isolate, Code::Flags flags)
+ : ZoneHolder(isolate),
+ CodeAssemblerT(isolate, ZoneHolder::zone(), 0, flags, "test"),
+ scope_(isolate) {}
+
+ Handle<Code> GenerateCodeCloseAndEscape() {
+ return scope_.CloseAndEscape(CodeAssemblerT::GenerateCode());
+ }
+
+ // Expose some internal methods.
+
+ Node* SmiShiftBitsConstant() {
+ return CodeAssemblerT::SmiShiftBitsConstant();
+ }
+
+ private:
+ HandleScope scope_;
+ LocalContext context_;
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/compiler/codegen-tester.h b/test/cctest/compiler/codegen-tester.h
index dbb9a72..3450c3a 100644
--- a/test/cctest/compiler/codegen-tester.h
+++ b/test/cctest/compiler/codegen-tester.h
@@ -256,7 +256,7 @@
// parameters from memory. Thereby it is possible to pass 64 bit parameters
// to the IR graph.
Node* Parameter(size_t index) {
- CHECK(index >= 0 && index < 4);
+ CHECK(index < 4);
return parameter_nodes_[index];
}
diff --git a/test/cctest/compiler/function-tester.h b/test/cctest/compiler/function-tester.h
index 555e049..c7304f1 100644
--- a/test/cctest/compiler/function-tester.h
+++ b/test/cctest/compiler/function-tester.h
@@ -42,16 +42,18 @@
CompileGraph(graph);
}
- FunctionTester(const CallInterfaceDescriptor& descriptor, Handle<Code> code)
+ FunctionTester(Handle<Code> code, int param_count)
: isolate(main_isolate()),
- function(
- (FLAG_allow_natives_syntax = true,
- NewFunction(BuildFunctionFromDescriptor(descriptor).c_str()))),
+ function((FLAG_allow_natives_syntax = true,
+ NewFunction(BuildFunction(param_count).c_str()))),
flags_(0) {
Compile(function);
function->ReplaceCode(*code);
}
+ FunctionTester(const CallInterfaceDescriptor& descriptor, Handle<Code> code)
+ : FunctionTester(code, descriptor.GetParameterCount()) {}
+
Isolate* isolate;
Handle<JSFunction> function;
@@ -59,11 +61,22 @@
return Execution::Call(isolate, function, undefined(), 0, nullptr);
}
+ MaybeHandle<Object> Call(Handle<Object> a) {
+ Handle<Object> args[] = {a};
+ return Execution::Call(isolate, function, undefined(), 1, args);
+ }
+
MaybeHandle<Object> Call(Handle<Object> a, Handle<Object> b) {
Handle<Object> args[] = {a, b};
return Execution::Call(isolate, function, undefined(), 2, args);
}
+ MaybeHandle<Object> Call(Handle<Object> a, Handle<Object> b,
+ Handle<Object> c) {
+ Handle<Object> args[] = {a, b, c};
+ return Execution::Call(isolate, function, undefined(), 3, args);
+ }
+
MaybeHandle<Object> Call(Handle<Object> a, Handle<Object> b, Handle<Object> c,
Handle<Object> d) {
Handle<Object> args[] = {a, b, c, d};
@@ -91,41 +104,56 @@
return try_catch.Message();
}
- void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b) {
- Handle<Object> result = Call(a, b).ToHandleChecked();
+ void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b,
+ Handle<Object> c, Handle<Object> d) {
+ Handle<Object> result = Call(a, b, c, d).ToHandleChecked();
CHECK(expected->SameValue(*result));
}
+ void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b,
+ Handle<Object> c) {
+ return CheckCall(expected, a, b, c, undefined());
+ }
+
+ void CheckCall(Handle<Object> expected, Handle<Object> a, Handle<Object> b) {
+ return CheckCall(expected, a, b, undefined());
+ }
+
void CheckCall(Handle<Object> expected, Handle<Object> a) {
CheckCall(expected, a, undefined());
}
- void CheckCall(Handle<Object> expected) {
- CheckCall(expected, undefined(), undefined());
- }
+ void CheckCall(Handle<Object> expected) { CheckCall(expected, undefined()); }
void CheckCall(double expected, double a, double b) {
CheckCall(Val(expected), Val(a), Val(b));
}
+ void CheckTrue(Handle<Object> a) { CheckCall(true_value(), a); }
+
void CheckTrue(Handle<Object> a, Handle<Object> b) {
CheckCall(true_value(), a, b);
}
- void CheckTrue(Handle<Object> a) { CheckCall(true_value(), a, undefined()); }
+ void CheckTrue(Handle<Object> a, Handle<Object> b, Handle<Object> c) {
+ CheckCall(true_value(), a, b, c);
+ }
+
+ void CheckTrue(Handle<Object> a, Handle<Object> b, Handle<Object> c,
+ Handle<Object> d) {
+ CheckCall(true_value(), a, b, c, d);
+ }
void CheckTrue(double a, double b) {
CheckCall(true_value(), Val(a), Val(b));
}
+ void CheckFalse(Handle<Object> a) { CheckCall(false_value(), a); }
+
void CheckFalse(Handle<Object> a, Handle<Object> b) {
CheckCall(false_value(), a, b);
}
- void CheckFalse(Handle<Object> a) {
- CheckCall(false_value(), a, undefined());
- }
-
void CheckFalse(double a, double b) {
CheckCall(false_value(), Val(a), Val(b));
}
@@ -194,6 +222,7 @@
CHECK(Compiler::Analyze(info.parse_info()));
CHECK(Compiler::EnsureDeoptimizationSupport(&info));
}
+ JSFunction::EnsureLiterals(function);
Handle<Code> code = Pipeline::GenerateCodeForTesting(&info);
CHECK(!code.is_null());
@@ -216,11 +245,6 @@
return function_string;
}
- std::string BuildFunctionFromDescriptor(
- const CallInterfaceDescriptor& descriptor) {
- return BuildFunction(descriptor.GetParameterCount());
- }
-
// Compile the given machine graph instead of the source of the function
// and replace the JSFunction's code with the result.
Handle<JSFunction> CompileGraph(Graph* graph) {
diff --git a/test/cctest/compiler/test-code-stub-assembler.cc b/test/cctest/compiler/test-code-assembler.cc
similarity index 60%
rename from test/cctest/compiler/test-code-stub-assembler.cc
rename to test/cctest/compiler/test-code-assembler.cc
index 37ba9e9..7f27a6f 100644
--- a/test/cctest/compiler/test-code-stub-assembler.cc
+++ b/test/cctest/compiler/test-code-assembler.cc
@@ -2,52 +2,54 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/interface-descriptors.h"
+#include "src/compiler/code-assembler.h"
#include "src/isolate.h"
+#include "test/cctest/compiler/code-assembler-tester.h"
#include "test/cctest/compiler/function-tester.h"
namespace v8 {
namespace internal {
namespace compiler {
+typedef CodeAssemblerTesterImpl<CodeAssembler> CodeAssemblerTester;
-class CodeStubAssemblerTester : public CodeStubAssembler {
- public:
- // Test generating code for a stub.
- CodeStubAssemblerTester(Isolate* isolate,
- const CallInterfaceDescriptor& descriptor)
- : CodeStubAssembler(isolate, isolate->runtime_zone(), descriptor,
- Code::ComputeFlags(Code::STUB), "test"),
- scope_(isolate) {}
+namespace {
- // Test generating code for a JS function (e.g. builtins).
- CodeStubAssemblerTester(Isolate* isolate, int parameter_count)
- : CodeStubAssembler(isolate, isolate->runtime_zone(), parameter_count,
- Code::ComputeFlags(Code::FUNCTION), "test"),
- scope_(isolate) {}
+Node* SmiTag(CodeAssemblerTester& m, Node* value) {
+ int32_t constant_value;
+ if (m.ToInt32Constant(value, constant_value) &&
+ Smi::IsValid(constant_value)) {
+ return m.SmiConstant(Smi::FromInt(constant_value));
+ }
+ return m.WordShl(value, m.SmiShiftBitsConstant());
+}
- private:
- HandleScope scope_;
- LocalContext context_;
-};
+Node* UndefinedConstant(CodeAssemblerTester& m) {
+ return m.LoadRoot(Heap::kUndefinedValueRootIndex);
+}
+Node* LoadObjectField(CodeAssemblerTester& m, Node* object, int offset,
+ MachineType rep = MachineType::AnyTagged()) {
+ return m.Load(rep, object, m.IntPtrConstant(offset - kHeapObjectTag));
+}
+
+} // namespace
TEST(SimpleSmiReturn) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
- m.Return(m.SmiTag(m.Int32Constant(37)));
+ CodeAssemblerTester m(isolate, descriptor);
+ m.Return(SmiTag(m, m.Int32Constant(37)));
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
MaybeHandle<Object> result = ft.Call();
CHECK_EQ(37, Handle<Smi>::cast(result.ToHandleChecked())->value());
}
-
TEST(SimpleIntPtrReturn) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
int test;
m.Return(m.IntPtrConstant(reinterpret_cast<intptr_t>(&test)));
Handle<Code> code = m.GenerateCode();
@@ -57,11 +59,10 @@
reinterpret_cast<intptr_t>(*result.ToHandleChecked()));
}
-
TEST(SimpleDoubleReturn) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
m.Return(m.NumberConstant(0.5));
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
@@ -69,13 +70,12 @@
CHECK_EQ(0.5, Handle<HeapNumber>::cast(result.ToHandleChecked())->value());
}
-
TEST(SimpleCallRuntime1Arg) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
- Node* b = m.SmiTag(m.Int32Constant(0));
+ Node* b = SmiTag(m, m.Int32Constant(0));
m.Return(m.CallRuntime(Runtime::kNumberToSmi, context, b));
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
@@ -83,13 +83,12 @@
CHECK_EQ(0, Handle<Smi>::cast(result.ToHandleChecked())->value());
}
-
TEST(SimpleTailCallRuntime1Arg) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
- Node* b = m.SmiTag(m.Int32Constant(0));
+ Node* b = SmiTag(m, m.Int32Constant(0));
m.TailCallRuntime(Runtime::kNumberToSmi, context, b);
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
@@ -97,14 +96,13 @@
CHECK_EQ(0, Handle<Smi>::cast(result.ToHandleChecked())->value());
}
-
TEST(SimpleCallRuntime2Arg) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
- Node* a = m.SmiTag(m.Int32Constant(2));
- Node* b = m.SmiTag(m.Int32Constant(4));
+ Node* a = SmiTag(m, m.Int32Constant(2));
+ Node* b = SmiTag(m, m.Int32Constant(4));
m.Return(m.CallRuntime(Runtime::kMathPow, context, a, b));
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
@@ -112,14 +110,13 @@
CHECK_EQ(16, Handle<Smi>::cast(result.ToHandleChecked())->value());
}
-
TEST(SimpleTailCallRuntime2Arg) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
- Node* a = m.SmiTag(m.Int32Constant(2));
- Node* b = m.SmiTag(m.Int32Constant(4));
+ Node* a = SmiTag(m, m.Int32Constant(2));
+ Node* b = SmiTag(m, m.Int32Constant(4));
m.TailCallRuntime(Runtime::kMathPow, context, a, b);
Handle<Code> code = m.GenerateCode();
FunctionTester ft(descriptor, code);
@@ -127,10 +124,95 @@
CHECK_EQ(16, Handle<Smi>::cast(result.ToHandleChecked())->value());
}
+namespace {
+
+Handle<JSFunction> CreateSumAllArgumentsFunction(FunctionTester& ft) {
+ const char* source =
+ "(function() {\n"
+ " var sum = 0 + this;\n"
+ " for (var i = 0; i < arguments.length; i++) {\n"
+ " sum += arguments[i];\n"
+ " }\n"
+ " return sum;\n"
+ "})";
+ return ft.NewFunction(source);
+}
+
+} // namespace
+
+TEST(SimpleCallJSFunction0Arg) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ const int kNumParams = 1;
+ CodeAssemblerTester m(isolate, kNumParams);
+ {
+ Node* function = m.Parameter(0);
+ Node* context = m.Parameter(kNumParams + 2);
+
+ Node* receiver = SmiTag(m, m.Int32Constant(42));
+
+ Callable callable = CodeFactory::Call(isolate);
+ Node* result = m.CallJS(callable, context, function, receiver);
+ m.Return(result);
+ }
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<JSFunction> sum = CreateSumAllArgumentsFunction(ft);
+ MaybeHandle<Object> result = ft.Call(sum);
+ CHECK_EQ(Smi::FromInt(42), *result.ToHandleChecked());
+}
+
+TEST(SimpleCallJSFunction1Arg) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ const int kNumParams = 2;
+ CodeAssemblerTester m(isolate, kNumParams);
+ {
+ Node* function = m.Parameter(0);
+ Node* context = m.Parameter(1);
+
+ Node* receiver = SmiTag(m, m.Int32Constant(42));
+ Node* a = SmiTag(m, m.Int32Constant(13));
+
+ Callable callable = CodeFactory::Call(isolate);
+ Node* result = m.CallJS(callable, context, function, receiver, a);
+ m.Return(result);
+ }
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<JSFunction> sum = CreateSumAllArgumentsFunction(ft);
+ MaybeHandle<Object> result = ft.Call(sum);
+ CHECK_EQ(Smi::FromInt(55), *result.ToHandleChecked());
+}
+
+TEST(SimpleCallJSFunction2Arg) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ const int kNumParams = 2;
+ CodeAssemblerTester m(isolate, kNumParams);
+ {
+ Node* function = m.Parameter(0);
+ Node* context = m.Parameter(1);
+
+ Node* receiver = SmiTag(m, m.Int32Constant(42));
+ Node* a = SmiTag(m, m.Int32Constant(13));
+ Node* b = SmiTag(m, m.Int32Constant(153));
+
+ Callable callable = CodeFactory::Call(isolate);
+ Node* result = m.CallJS(callable, context, function, receiver, a, b);
+ m.Return(result);
+ }
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<JSFunction> sum = CreateSumAllArgumentsFunction(ft);
+ MaybeHandle<Object> result = ft.Call(sum);
+ CHECK_EQ(Smi::FromInt(208), *result.ToHandleChecked());
+}
+
TEST(VariableMerge1) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Label l1(&m), l2(&m), merge(&m);
Node* temp = m.Int32Constant(0);
@@ -149,7 +231,7 @@
TEST(VariableMerge2) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Label l1(&m), l2(&m), merge(&m);
Node* temp = m.Int32Constant(0);
@@ -170,7 +252,7 @@
TEST(VariableMerge3) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Variable var2(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Label l1(&m), l2(&m), merge(&m);
@@ -195,7 +277,7 @@
TEST(VariableMergeBindFirst) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Label l1(&m), l2(&m), merge(&m, &var1), end(&m);
Node* temp = m.Int32Constant(0);
@@ -221,7 +303,7 @@
TEST(VariableMergeSwitch) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged);
CodeStubAssembler::Label l1(&m), l2(&m), default_label(&m);
CodeStubAssembler::Label* labels[] = {&l1, &l2};
@@ -240,102 +322,10 @@
m.Return(temp);
}
-TEST(FixedArrayAccessSmiIndex) {
- Isolate* isolate(CcTest::InitIsolateOnce());
- VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
- Handle<FixedArray> array = isolate->factory()->NewFixedArray(5);
- array->set(4, Smi::FromInt(733));
- 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();
- CHECK_EQ(733, Handle<Smi>::cast(result.ToHandleChecked())->value());
-}
-
-TEST(LoadHeapNumberValue) {
- Isolate* isolate(CcTest::InitIsolateOnce());
- VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
- Handle<HeapNumber> number = isolate->factory()->NewHeapNumber(1234);
- m.Return(m.SmiTag(
- m.ChangeFloat64ToUint32(m.LoadHeapNumberValue(m.HeapConstant(number)))));
- Handle<Code> code = m.GenerateCode();
- FunctionTester ft(descriptor, code);
- MaybeHandle<Object> result = ft.Call();
- CHECK_EQ(1234, Handle<Smi>::cast(result.ToHandleChecked())->value());
-}
-
-TEST(LoadInstanceType) {
- Isolate* isolate(CcTest::InitIsolateOnce());
- VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
- Handle<HeapObject> undefined = isolate->factory()->undefined_value();
- m.Return(m.SmiTag(m.LoadInstanceType(m.HeapConstant(undefined))));
- Handle<Code> code = m.GenerateCode();
- FunctionTester ft(descriptor, code);
- MaybeHandle<Object> result = ft.Call();
- CHECK_EQ(InstanceType::ODDBALL_TYPE,
- Handle<Smi>::cast(result.ToHandleChecked())->value());
-}
-
-namespace {
-
-class TestBitField : public BitField<unsigned, 3, 3> {};
-
-} // namespace
-
-TEST(BitFieldDecode) {
- Isolate* isolate(CcTest::InitIsolateOnce());
- VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
- m.Return(m.SmiTag(m.BitFieldDecode<TestBitField>(m.Int32Constant(0x2f))));
- Handle<Code> code = m.GenerateCode();
- FunctionTester ft(descriptor, code);
- MaybeHandle<Object> result = ft.Call();
- // value = 00101111
- // mask = 00111000
- // result = 101
- CHECK_EQ(5, Handle<Smi>::cast(result.ToHandleChecked())->value());
-}
-
-namespace {
-
-Handle<JSFunction> CreateFunctionFromCode(int parameter_count_with_receiver,
- Handle<Code> code) {
- Isolate* isolate = code->GetIsolate();
- Handle<String> name = isolate->factory()->InternalizeUtf8String("test");
- Handle<JSFunction> function =
- isolate->factory()->NewFunctionWithoutPrototype(name, code);
- function->shared()->set_internal_formal_parameter_count(
- parameter_count_with_receiver - 1); // Implicit undefined receiver.
- return function;
-}
-
-} // namespace
-
-TEST(JSFunction) {
- const int kNumParams = 3; // Receiver, left, right.
- Isolate* isolate(CcTest::InitIsolateOnce());
- CodeStubAssemblerTester m(isolate, kNumParams);
- m.Return(m.SmiTag(m.Int32Add(m.SmiToWord32(m.Parameter(1)),
- m.SmiToWord32(m.Parameter(2)))));
- Handle<Code> code = m.GenerateCode();
- Handle<JSFunction> function = CreateFunctionFromCode(kNumParams, code);
- Handle<Object> args[] = {Handle<Smi>(Smi::FromInt(23), isolate),
- Handle<Smi>(Smi::FromInt(34), isolate)};
- MaybeHandle<Object> result =
- Execution::Call(isolate, function, isolate->factory()->undefined_value(),
- arraysize(args), args);
- CHECK_EQ(57, Handle<Smi>::cast(result.ToHandleChecked())->value());
-}
-
TEST(SplitEdgeBranchMerge) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Label l1(&m), merge(&m);
m.Branch(m.Int32Constant(1), &l1, &merge);
m.Bind(&l1);
@@ -347,7 +337,7 @@
TEST(SplitEdgeSwitchMerge) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
CodeStubAssembler::Label l1(&m), l2(&m), l3(&m), default_label(&m);
CodeStubAssembler::Label* labels[] = {&l1, &l2};
int32_t values[] = {1, 2};
@@ -365,7 +355,7 @@
TEST(TestToConstant) {
Isolate* isolate(CcTest::InitIsolateOnce());
VoidDescriptor descriptor(isolate);
- CodeStubAssemblerTester m(isolate, descriptor);
+ CodeAssemblerTester m(isolate, descriptor);
int32_t value32;
int64_t value64;
Node* a = m.Int32Constant(5);
@@ -380,15 +370,69 @@
CHECK(m.ToInt32Constant(a, value32));
CHECK(m.ToInt64Constant(a, value64));
- a = m.UndefinedConstant();
+ a = UndefinedConstant(m);
CHECK(!m.ToInt32Constant(a, value32));
CHECK(!m.ToInt64Constant(a, value64));
- a = m.UndefinedConstant();
+ a = UndefinedConstant(m);
CHECK(!m.ToInt32Constant(a, value32));
CHECK(!m.ToInt64Constant(a, value64));
}
+TEST(DeferredCodePhiHints) {
+ typedef compiler::Node Node;
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeAssemblerTester m(isolate, descriptor);
+ Label block1(&m, Label::kDeferred);
+ m.Goto(&block1);
+ m.Bind(&block1);
+ {
+ Variable var_object(&m, MachineRepresentation::kTagged);
+ Label loop(&m, &var_object);
+ var_object.Bind(m.IntPtrConstant(0));
+ m.Goto(&loop);
+ m.Bind(&loop);
+ {
+ Node* map = LoadObjectField(m, var_object.value(), JSObject::kMapOffset);
+ var_object.Bind(map);
+ m.Goto(&loop);
+ }
+ }
+ CHECK(!m.GenerateCode().is_null());
+}
+
+TEST(TestOutOfScopeVariable) {
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeAssemblerTester m(isolate, descriptor);
+ Label block1(&m);
+ Label block2(&m);
+ Label block3(&m);
+ Label block4(&m);
+ m.Branch(m.WordEqual(m.Parameter(0), m.IntPtrConstant(0)), &block1, &block4);
+ m.Bind(&block4);
+ {
+ Variable var_object(&m, MachineRepresentation::kTagged);
+ m.Branch(m.WordEqual(m.Parameter(0), m.IntPtrConstant(0)), &block2,
+ &block3);
+
+ m.Bind(&block2);
+ var_object.Bind(m.IntPtrConstant(55));
+ m.Goto(&block1);
+
+ m.Bind(&block3);
+ var_object.Bind(m.IntPtrConstant(66));
+ m.Goto(&block1);
+ }
+ m.Bind(&block1);
+ CHECK(!m.GenerateCode().is_null());
+}
+
} // 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 9781aeb..8d0ca8b 100644
--- a/test/cctest/compiler/test-gap-resolver.cc
+++ b/test/cctest/compiler/test-gap-resolver.cc
@@ -116,9 +116,7 @@
InstructionOperand source = FromKey(it->first);
InstructionOperand destination = FromKey(it->second);
MoveOperands mo(source, destination);
- PrintableMoveOperands pmo = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN),
- &mo};
+ PrintableMoveOperands pmo = {RegisterConfiguration::Turbofan(), &mo};
os << pmo;
}
return os;
@@ -167,8 +165,10 @@
ParallelMove* Create(int size) {
ParallelMove* parallel_move = new (main_zone()) ParallelMove(main_zone());
std::set<InstructionOperand, CompareOperandModuloType> seen;
+ MachineRepresentation rep = RandomRepresentation();
for (int i = 0; i < size; ++i) {
- MoveOperands mo(CreateRandomOperand(true), CreateRandomOperand(false));
+ MoveOperands mo(CreateRandomOperand(true, rep),
+ CreateRandomOperand(false, rep));
if (!mo.IsRedundant() && seen.find(mo.destination()) == seen.end()) {
parallel_move->AddMove(mo.source(), mo.destination());
seen.insert(mo.destination());
@@ -179,52 +179,54 @@
private:
MachineRepresentation RandomRepresentation() {
- int index = rng_->NextInt(3);
+ int index = rng_->NextInt(5);
switch (index) {
case 0:
return MachineRepresentation::kWord32;
case 1:
return MachineRepresentation::kWord64;
case 2:
+ return MachineRepresentation::kFloat32;
+ case 3:
+ return MachineRepresentation::kFloat64;
+ case 4:
return MachineRepresentation::kTagged;
}
UNREACHABLE();
return MachineRepresentation::kNone;
}
- MachineRepresentation RandomDoubleRepresentation() {
- int index = rng_->NextInt(2);
- if (index == 0) return MachineRepresentation::kFloat64;
- return MachineRepresentation::kFloat32;
- }
+ InstructionOperand CreateRandomOperand(bool is_source,
+ MachineRepresentation rep) {
+ auto conf = RegisterConfiguration::Turbofan();
+ auto GetRegisterCode = [&conf](MachineRepresentation rep, int index) {
+ switch (rep) {
+ case MachineRepresentation::kFloat32:
+ case MachineRepresentation::kFloat64:
+ return conf->RegisterConfiguration::GetAllocatableDoubleCode(index);
+ break;
- InstructionOperand CreateRandomOperand(bool is_source) {
+ default:
+ return conf->RegisterConfiguration::GetAllocatableGeneralCode(index);
+ break;
+ }
+ UNREACHABLE();
+ return static_cast<int>(Register::kCode_no_reg);
+ };
int index = rng_->NextInt(7);
// destination can't be Constant.
- switch (rng_->NextInt(is_source ? 7 : 6)) {
+ switch (rng_->NextInt(is_source ? 5 : 4)) {
case 0:
- return AllocatedOperand(LocationOperand::STACK_SLOT,
- RandomRepresentation(), index);
+ return AllocatedOperand(LocationOperand::STACK_SLOT, rep, index);
case 1:
- return AllocatedOperand(LocationOperand::STACK_SLOT,
- RandomDoubleRepresentation(), index);
+ return AllocatedOperand(LocationOperand::REGISTER, rep, index);
case 2:
- return AllocatedOperand(LocationOperand::REGISTER,
- RandomRepresentation(), index);
+ return ExplicitOperand(LocationOperand::REGISTER, rep,
+ GetRegisterCode(rep, 1));
case 3:
- return AllocatedOperand(LocationOperand::REGISTER,
- RandomDoubleRepresentation(), index);
+ return ExplicitOperand(LocationOperand::STACK_SLOT, rep,
+ GetRegisterCode(rep, index));
case 4:
- return ExplicitOperand(
- LocationOperand::REGISTER, RandomRepresentation(),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(1));
- case 5:
- return ExplicitOperand(
- LocationOperand::STACK_SLOT, RandomRepresentation(),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(index));
- case 6:
return ConstantOperand(index);
}
UNREACHABLE();
diff --git a/test/cctest/compiler/test-js-context-specialization.cc b/test/cctest/compiler/test-js-context-specialization.cc
index c7cd47a..e9bf064 100644
--- a/test/cctest/compiler/test-js-context-specialization.cc
+++ b/test/cctest/compiler/test-js-context-specialization.cc
@@ -186,81 +186,6 @@
}
-// TODO(titzer): factor out common code with effects checking in typed lowering.
-static void CheckEffectInput(Node* effect, Node* use) {
- CHECK_EQ(effect, NodeProperties::GetEffectInput(use));
-}
-
-
-TEST(SpecializeToContext) {
- ContextSpecializationTester t;
-
- Node* start = t.graph()->NewNode(t.common()->Start(0));
- t.graph()->SetStart(start);
-
- // Make a context and initialize it a bit for this test.
- Handle<Context> native = t.factory()->NewNativeContext();
- Handle<Object> expected = t.factory()->InternalizeUtf8String("gboy!");
- const int slot = Context::NATIVE_CONTEXT_INDEX;
- native->set(slot, *expected);
-
- Node* const_context = t.jsgraph()->Constant(native);
- Node* param_context = t.graph()->NewNode(t.common()->Parameter(0), start);
-
- {
- // Check that specialization replaces values and forwards effects
- // correctly, and folds values from constant and non-constant contexts
- Node* effect_in = start;
- Node* load = t.graph()->NewNode(t.javascript()->LoadContext(0, slot, true),
- const_context, const_context, effect_in);
-
-
- Node* value_use =
- t.graph()->NewNode(t.simplified()->ChangeTaggedToInt32(), load);
- Node* other_load =
- t.graph()->NewNode(t.javascript()->LoadContext(0, slot, true),
- param_context, param_context, load);
- Node* effect_use = other_load;
- Node* other_use =
- t.graph()->NewNode(t.simplified()->ChangeTaggedToInt32(), other_load);
-
- Node* add = t.graph()->NewNode(
- t.javascript()->Add(BinaryOperationHints::Any()), value_use, other_use,
- param_context, t.jsgraph()->EmptyFrameState(),
- t.jsgraph()->EmptyFrameState(), other_load, start);
-
- Node* ret =
- t.graph()->NewNode(t.common()->Return(), add, effect_use, start);
- Node* end = t.graph()->NewNode(t.common()->End(1), ret);
- USE(end);
- t.graph()->SetEnd(end);
-
- // Double check the above graph is what we expect, or the test is broken.
- CheckEffectInput(effect_in, load);
- CheckEffectInput(load, effect_use);
-
- // Perform the reduction on the entire graph.
- GraphReducer graph_reducer(t.main_zone(), t.graph());
- JSContextSpecialization spec(&graph_reducer, t.jsgraph(),
- MaybeHandle<Context>());
- graph_reducer.AddReducer(&spec);
- graph_reducer.ReduceGraph();
-
- // Effects should have been forwarded (not replaced with a value).
- CheckEffectInput(effect_in, effect_use);
-
- // Use of {other_load} should not have been replaced.
- CHECK_EQ(other_load, other_use->InputAt(0));
-
- Node* replacement = value_use->InputAt(0);
- HeapObjectMatcher match(replacement);
- CHECK(match.HasValue());
- CHECK_EQ(*expected, *match.Value());
- }
- // TODO(titzer): clean up above test and test more complicated effects.
-}
-
-
TEST(SpecializeJSFunction_ToConstant1) {
FunctionTester T(
"(function() { var x = 1; function inc(a)"
@@ -300,10 +225,14 @@
FunctionTester T(
"(function() { if (false) { var x = 1; } function inc(a)"
" { return x; } return inc; })()"); // x is undefined!
-
- CHECK(T.Call(T.Val(0.0), T.Val(0.0)).ToHandleChecked()->IsUndefined());
- CHECK(T.Call(T.Val(2.0), T.Val(0.0)).ToHandleChecked()->IsUndefined());
- CHECK(T.Call(T.Val(-2.1), T.Val(0.0)).ToHandleChecked()->IsUndefined());
+ i::Isolate* isolate = CcTest::i_isolate();
+ CHECK(
+ T.Call(T.Val(0.0), T.Val(0.0)).ToHandleChecked()->IsUndefined(isolate));
+ CHECK(
+ T.Call(T.Val(2.0), T.Val(0.0)).ToHandleChecked()->IsUndefined(isolate));
+ CHECK(T.Call(T.Val(-2.1), T.Val(0.0))
+ .ToHandleChecked()
+ ->IsUndefined(isolate));
}
{
diff --git a/test/cctest/compiler/test-js-typed-lowering.cc b/test/cctest/compiler/test-js-typed-lowering.cc
index 0075de5..0dac0da 100644
--- a/test/cctest/compiler/test-js-typed-lowering.cc
+++ b/test/cctest/compiler/test-js-typed-lowering.cc
@@ -47,7 +47,8 @@
Graph graph;
Typer typer;
Node* context_node;
- BinaryOperationHints const hints = BinaryOperationHints::Any();
+ BinaryOperationHints const binop_hints = BinaryOperationHints::Any();
+ CompareOperationHints const compare_hints = CompareOperationHints::Any();
Node* Parameter(Type* t, int32_t index = 0) {
Node* n = graph.NewNode(common.Parameter(index), graph.start());
@@ -255,11 +256,11 @@
TEST(NumberBinops) {
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.Add(R.hints), R.simplified.NumberAdd(),
- R.javascript.Subtract(R.hints), R.simplified.NumberSubtract(),
- R.javascript.Multiply(R.hints), R.simplified.NumberMultiply(),
- R.javascript.Divide(R.hints), R.simplified.NumberDivide(),
- R.javascript.Modulus(R.hints), R.simplified.NumberModulus(),
+ R.javascript.Add(R.binop_hints), R.simplified.NumberAdd(),
+ R.javascript.Subtract(R.binop_hints), R.simplified.NumberSubtract(),
+ R.javascript.Multiply(R.binop_hints), R.simplified.NumberMultiply(),
+ R.javascript.Divide(R.binop_hints), R.simplified.NumberDivide(),
+ R.javascript.Modulus(R.binop_hints), R.simplified.NumberModulus(),
};
for (size_t i = 0; i < arraysize(kNumberTypes); ++i) {
@@ -301,11 +302,11 @@
public:
JSBitwiseShiftTypedLoweringTester() : JSTypedLoweringTester() {
int i = 0;
- set(i++, javascript.ShiftLeft(hints), true);
+ set(i++, javascript.ShiftLeft(binop_hints), true);
set(i++, simplified.NumberShiftLeft(), false);
- set(i++, javascript.ShiftRight(hints), true);
+ set(i++, javascript.ShiftRight(binop_hints), true);
set(i++, simplified.NumberShiftRight(), false);
- set(i++, javascript.ShiftRightLogical(hints), false);
+ set(i++, javascript.ShiftRightLogical(binop_hints), false);
set(i++, simplified.NumberShiftRightLogical(), false);
}
static const int kNumberOps = 6;
@@ -357,11 +358,11 @@
public:
JSBitwiseTypedLoweringTester() : JSTypedLoweringTester() {
int i = 0;
- set(i++, javascript.BitwiseOr(hints), true);
+ set(i++, javascript.BitwiseOr(binop_hints), true);
set(i++, simplified.NumberBitwiseOr(), true);
- set(i++, javascript.BitwiseXor(hints), true);
+ set(i++, javascript.BitwiseXor(binop_hints), true);
set(i++, simplified.NumberBitwiseXor(), true);
- set(i++, javascript.BitwiseAnd(hints), true);
+ set(i++, javascript.BitwiseAnd(binop_hints), true);
set(i++, simplified.NumberBitwiseAnd(), true);
}
static const int kNumberOps = 6;
@@ -492,7 +493,7 @@
for (size_t i = 0; i < arraysize(others); i++) {
Type* t = Type::Union(Type::Number(), others[i], R.main_zone());
Node* r = R.ReduceUnop(R.javascript.ToNumber(), t);
- CHECK_EQ(IrOpcode::kJSToNumber, r->opcode());
+ CHECK_EQ(IrOpcode::kPlainPrimitiveToNumber, r->opcode());
}
}
@@ -571,10 +572,14 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.LessThan(), R.simplified.StringLessThan(),
- R.javascript.LessThanOrEqual(), R.simplified.StringLessThanOrEqual(),
- R.javascript.GreaterThan(), R.simplified.StringLessThan(),
- R.javascript.GreaterThanOrEqual(), R.simplified.StringLessThanOrEqual()};
+ R.javascript.LessThan(CompareOperationHints::Any()),
+ R.simplified.StringLessThan(),
+ R.javascript.LessThanOrEqual(CompareOperationHints::Any()),
+ R.simplified.StringLessThanOrEqual(),
+ R.javascript.GreaterThan(CompareOperationHints::Any()),
+ R.simplified.StringLessThan(),
+ R.javascript.GreaterThanOrEqual(CompareOperationHints::Any()),
+ R.simplified.StringLessThanOrEqual()};
for (size_t i = 0; i < arraysize(kStringTypes); i++) {
Node* p0 = R.Parameter(kStringTypes[i], 0);
@@ -618,10 +623,14 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.LessThan(), R.simplified.NumberLessThan(),
- R.javascript.LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
- R.javascript.GreaterThan(), R.simplified.NumberLessThan(),
- R.javascript.GreaterThanOrEqual(), R.simplified.NumberLessThanOrEqual()};
+ R.javascript.LessThan(CompareOperationHints::Any()),
+ R.simplified.NumberLessThan(),
+ R.javascript.LessThanOrEqual(CompareOperationHints::Any()),
+ R.simplified.NumberLessThanOrEqual(),
+ R.javascript.GreaterThan(CompareOperationHints::Any()),
+ R.simplified.NumberLessThan(),
+ R.javascript.GreaterThanOrEqual(CompareOperationHints::Any()),
+ R.simplified.NumberLessThanOrEqual()};
Node* const p0 = R.Parameter(Type::Number(), 0);
Node* const p1 = R.Parameter(Type::Number(), 1);
@@ -655,7 +664,8 @@
for (size_t j = 0; j < arraysize(types); j++) {
Node* p1 = R.Parameter(types[j], 1);
{
- const Operator* less_than = R.javascript.LessThan();
+ const Operator* less_than =
+ R.javascript.LessThan(CompareOperationHints::Any());
Node* cmp = R.Binop(less_than, p0, p1);
Node* r = R.reduce(cmp);
if (types[i]->Is(Type::String()) && types[j]->Is(Type::String())) {
@@ -700,14 +710,14 @@
case 2:
effect_use = R.graph.NewNode(R.common.EffectPhi(1), ton, R.start());
case 3:
- effect_use =
- R.graph.NewNode(R.javascript.Add(R.hints), ton, ton, R.context(),
- frame_state, frame_state, ton, R.start());
+ effect_use = R.graph.NewNode(R.javascript.Add(R.binop_hints), ton, ton,
+ R.context(), frame_state, frame_state, ton,
+ R.start());
break;
case 4:
- effect_use =
- R.graph.NewNode(R.javascript.Add(R.hints), p0, p0, R.context(),
- frame_state, frame_state, ton, R.start());
+ effect_use = R.graph.NewNode(R.javascript.Add(R.binop_hints), p0, p0,
+ R.context(), frame_state, frame_state, ton,
+ R.start());
break;
case 5:
effect_use = R.graph.NewNode(R.common.Return(), p0, ton, R.start());
@@ -801,7 +811,8 @@
{
const Operator* op =
- strict ? R->javascript.StrictEqual() : R->javascript.Equal();
+ strict ? R->javascript.StrictEqual(CompareOperationHints::Any())
+ : R->javascript.Equal(CompareOperationHints::Any());
Node* eq = R->Binop(op, p0, p1);
Node* r = R->reduce(eq);
R->CheckBinop(expected, r);
@@ -809,7 +820,8 @@
{
const Operator* op =
- strict ? R->javascript.StrictNotEqual() : R->javascript.NotEqual();
+ strict ? R->javascript.StrictNotEqual(CompareOperationHints::Any())
+ : R->javascript.NotEqual(CompareOperationHints::Any());
Node* ne = R->Binop(op, p0, p1);
Node* n = R->reduce(ne);
CHECK_EQ(IrOpcode::kBooleanNot, n->opcode());
@@ -876,14 +888,22 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.Equal(), R.simplified.NumberEqual(),
- R.javascript.Add(R.hints), R.simplified.NumberAdd(),
- R.javascript.Subtract(R.hints), R.simplified.NumberSubtract(),
- R.javascript.Multiply(R.hints), R.simplified.NumberMultiply(),
- R.javascript.Divide(R.hints), R.simplified.NumberDivide(),
- R.javascript.Modulus(R.hints), R.simplified.NumberModulus(),
- R.javascript.LessThan(), R.simplified.NumberLessThan(),
- R.javascript.LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
+ R.javascript.Equal(R.compare_hints),
+ R.simplified.NumberEqual(),
+ R.javascript.Add(R.binop_hints),
+ R.simplified.NumberAdd(),
+ R.javascript.Subtract(R.binop_hints),
+ R.simplified.NumberSubtract(),
+ R.javascript.Multiply(R.binop_hints),
+ R.simplified.NumberMultiply(),
+ R.javascript.Divide(R.binop_hints),
+ R.simplified.NumberDivide(),
+ R.javascript.Modulus(R.binop_hints),
+ R.simplified.NumberModulus(),
+ R.javascript.LessThan(R.compare_hints),
+ R.simplified.NumberLessThan(),
+ R.javascript.LessThanOrEqual(R.compare_hints),
+ R.simplified.NumberLessThanOrEqual(),
};
for (size_t j = 0; j < arraysize(ops); j += 2) {
@@ -904,9 +924,9 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.Subtract(R.hints), R.simplified.NumberSubtract(),
- R.javascript.Multiply(R.hints), R.simplified.NumberMultiply(),
- R.javascript.Divide(R.hints), R.simplified.NumberDivide(),
+ R.javascript.Subtract(R.binop_hints), R.simplified.NumberSubtract(),
+ R.javascript.Multiply(R.binop_hints), R.simplified.NumberMultiply(),
+ R.javascript.Divide(R.binop_hints), R.simplified.NumberDivide(),
};
for (size_t j = 0; j < arraysize(ops); j += 2) {
@@ -929,10 +949,10 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.Add(R.hints), R.simplified.NumberAdd(),
- R.javascript.Subtract(R.hints), R.simplified.NumberSubtract(),
- R.javascript.Multiply(R.hints), R.simplified.NumberMultiply(),
- R.javascript.Divide(R.hints), R.simplified.NumberDivide(),
+ R.javascript.Add(R.binop_hints), R.simplified.NumberAdd(),
+ R.javascript.Subtract(R.binop_hints), R.simplified.NumberSubtract(),
+ R.javascript.Multiply(R.binop_hints), R.simplified.NumberMultiply(),
+ R.javascript.Divide(R.binop_hints), R.simplified.NumberDivide(),
};
for (size_t j = 0; j < arraysize(ops); j += 2) {
@@ -967,8 +987,9 @@
JSTypedLoweringTester R;
const Operator* ops[] = {
- R.javascript.GreaterThan(), R.simplified.NumberLessThan(),
- R.javascript.GreaterThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
+ R.javascript.GreaterThan(R.compare_hints), R.simplified.NumberLessThan(),
+ R.javascript.GreaterThanOrEqual(R.compare_hints),
+ R.simplified.NumberLessThanOrEqual(),
};
for (size_t j = 0; j < arraysize(ops); j += 2) {
@@ -1178,16 +1199,16 @@
};
Entry ops[] = {
- {R.javascript.LessThan(), R.machine.Uint32LessThan(),
+ {R.javascript.LessThan(R.compare_hints), R.machine.Uint32LessThan(),
R.machine.Int32LessThan(), R.simplified.NumberLessThan(), false},
- {R.javascript.LessThanOrEqual(), R.machine.Uint32LessThanOrEqual(),
- R.machine.Int32LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
- false},
- {R.javascript.GreaterThan(), R.machine.Uint32LessThan(),
+ {R.javascript.LessThanOrEqual(R.compare_hints),
+ R.machine.Uint32LessThanOrEqual(), R.machine.Int32LessThanOrEqual(),
+ R.simplified.NumberLessThanOrEqual(), false},
+ {R.javascript.GreaterThan(R.compare_hints), R.machine.Uint32LessThan(),
R.machine.Int32LessThan(), R.simplified.NumberLessThan(), true},
- {R.javascript.GreaterThanOrEqual(), R.machine.Uint32LessThanOrEqual(),
- R.machine.Int32LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
- true}};
+ {R.javascript.GreaterThanOrEqual(R.compare_hints),
+ R.machine.Uint32LessThanOrEqual(), R.machine.Int32LessThanOrEqual(),
+ R.simplified.NumberLessThanOrEqual(), true}};
for (size_t o = 0; o < arraysize(ops); o++) {
for (size_t i = 0; i < arraysize(kNumberTypes); i++) {
diff --git a/test/cctest/compiler/test-linkage.cc b/test/cctest/compiler/test-linkage.cc
index dc83f4d..436b0f3 100644
--- a/test/cctest/compiler/test-linkage.cc
+++ b/test/cctest/compiler/test-linkage.cc
@@ -7,6 +7,7 @@
#include "src/parsing/parser.h"
#include "src/zone.h"
+#include "src/code-factory.h"
#include "src/compiler/common-operator.h"
#include "src/compiler/graph.h"
#include "src/compiler/linkage.h"
@@ -97,14 +98,12 @@
TEST(TestLinkageStubCall) {
Isolate* isolate = CcTest::InitIsolateOnce();
Zone zone(isolate->allocator());
- ToNumberStub stub(isolate);
+ Callable callable = CodeFactory::ToNumber(isolate);
CompilationInfo info(ArrayVector("test"), isolate, &zone,
Code::ComputeFlags(Code::STUB));
- CallInterfaceDescriptor interface_descriptor =
- stub.GetCallInterfaceDescriptor();
CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
- isolate, &zone, interface_descriptor, stub.GetStackParameterCount(),
- CallDescriptor::kNoFlags, Operator::kNoProperties);
+ isolate, &zone, callable.descriptor(), 0, CallDescriptor::kNoFlags,
+ Operator::kNoProperties);
CHECK(descriptor);
CHECK_EQ(0, static_cast<int>(descriptor->StackParameterCount()));
CHECK_EQ(1, static_cast<int>(descriptor->ReturnCount()));
diff --git a/test/cctest/compiler/test-machine-operator-reducer.cc b/test/cctest/compiler/test-machine-operator-reducer.cc
index 86888e9..799a804 100644
--- a/test/cctest/compiler/test-machine-operator-reducer.cc
+++ b/test/cctest/compiler/test-machine-operator-reducer.cc
@@ -616,13 +616,8 @@
R.CheckDontPutConstantOnRight(-440197);
Node* x = R.Parameter(0);
- Node* y = R.Parameter(1);
- Node* zero = R.Constant<int32_t>(0);
- Node* sub = R.graph.NewNode(R.machine.Int32Sub(), x, y);
R.CheckFoldBinop<int32_t>(0, x, x); // x < x => 0
- R.CheckFoldBinop(x, y, sub, zero); // x - y < 0 => x < y
- R.CheckFoldBinop(y, x, zero, sub); // 0 < x - y => y < x
}
@@ -640,13 +635,8 @@
FOR_INT32_INPUTS(i) { R.CheckDontPutConstantOnRight<int32_t>(*i); }
Node* x = R.Parameter(0);
- Node* y = R.Parameter(1);
- Node* zero = R.Constant<int32_t>(0);
- Node* sub = R.graph.NewNode(R.machine.Int32Sub(), x, y);
R.CheckFoldBinop<int32_t>(1, x, x); // x <= x => 1
- R.CheckFoldBinop(x, y, sub, zero); // x - y <= 0 => x <= y
- R.CheckFoldBinop(y, x, zero, sub); // 0 <= x - y => y <= x
}
diff --git a/test/cctest/compiler/test-multiple-return.cc b/test/cctest/compiler/test-multiple-return.cc
index 53bae5e..aa7ec02 100644
--- a/test/cctest/compiler/test-multiple-return.cc
+++ b/test/cctest/compiler/test-multiple-return.cc
@@ -27,8 +27,7 @@
int param_count) {
MachineSignature::Builder msig(zone, return_count, param_count);
LocationSignature::Builder locations(zone, return_count, param_count);
- const RegisterConfiguration* config =
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN);
+ const RegisterConfiguration* config = RegisterConfiguration::Turbofan();
// Add return location(s).
CHECK(return_count <= config->num_allocatable_general_registers());
diff --git a/test/cctest/compiler/test-representation-change.cc b/test/cctest/compiler/test-representation-change.cc
index 76aa390..0d6b5b2 100644
--- a/test/cctest/compiler/test-representation-change.cc
+++ b/test/cctest/compiler/test-representation-change.cc
@@ -83,12 +83,20 @@
return n;
}
+ Node* Return(Node* input) {
+ Node* n = graph()->NewNode(common()->Return(), input, graph()->start(),
+ graph()->start());
+ return n;
+ }
+
void CheckTypeError(MachineRepresentation from, Type* from_type,
MachineRepresentation to) {
changer()->testing_type_errors_ = true;
changer()->type_error_ = false;
Node* n = Parameter(0);
- Node* c = changer()->GetRepresentationFor(n, from, from_type, to);
+ Node* use = Return(n);
+ Node* c = changer()->GetRepresentationFor(n, from, from_type, use,
+ UseInfo(to, Truncation::None()));
CHECK(changer()->type_error_);
CHECK_EQ(n, c);
}
@@ -96,7 +104,9 @@
void CheckNop(MachineRepresentation from, Type* from_type,
MachineRepresentation to) {
Node* n = Parameter(0);
- Node* c = changer()->GetRepresentationFor(n, from, from_type, to);
+ Node* use = Return(n);
+ Node* c = changer()->GetRepresentationFor(n, from, from_type, use,
+ UseInfo(to, Truncation::None()));
CHECK_EQ(n, c);
}
};
@@ -113,15 +123,17 @@
RepresentationChangerTester r;
Node* true_node = r.jsgraph()->TrueConstant();
+ Node* true_use = r.Return(true_node);
Node* true_bit = r.changer()->GetRepresentationFor(
- true_node, MachineRepresentation::kTagged, Type::None(),
- MachineRepresentation::kBit);
+ true_node, MachineRepresentation::kTagged, Type::None(), true_use,
+ UseInfo(MachineRepresentation::kBit, Truncation::None()));
r.CheckInt32Constant(true_bit, 1);
Node* false_node = r.jsgraph()->FalseConstant();
+ Node* false_use = r.Return(false_node);
Node* false_bit = r.changer()->GetRepresentationFor(
- false_node, MachineRepresentation::kTagged, Type::None(),
- MachineRepresentation::kBit);
+ false_node, MachineRepresentation::kTagged, Type::None(), false_use,
+ UseInfo(MachineRepresentation::kBit, Truncation::None()));
r.CheckInt32Constant(false_bit, 0);
}
@@ -131,9 +143,10 @@
for (int i = -5; i < 5; i++) {
Node* node = r.jsgraph()->Int32Constant(i);
+ Node* use = r.Return(node);
Node* val = r.changer()->GetRepresentationFor(
- node, MachineRepresentation::kBit, Type::Boolean(),
- MachineRepresentation::kTagged);
+ node, MachineRepresentation::kBit, Type::Boolean(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
r.CheckHeapConstant(val, i == 0 ? r.isolate()->heap()->false_value()
: r.isolate()->heap()->true_value());
}
@@ -146,49 +159,54 @@
{
FOR_FLOAT64_INPUTS(i) {
Node* n = r.jsgraph()->Float64Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::None(),
- MachineRepresentation::kTagged);
- r.CheckNumberConstant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::None(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
+ r.CheckNumberConstant(c, *i);
}
}
{
FOR_FLOAT64_INPUTS(i) {
Node* n = r.jsgraph()->Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::None(),
- MachineRepresentation::kTagged);
- r.CheckNumberConstant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::None(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
+ r.CheckNumberConstant(c, *i);
}
}
{
FOR_FLOAT32_INPUTS(i) {
Node* n = r.jsgraph()->Float32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat32, Type::None(),
- MachineRepresentation::kTagged);
- r.CheckNumberConstant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat32, Type::None(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
+ r.CheckNumberConstant(c, *i);
}
}
{
FOR_INT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Signed32(),
- MachineRepresentation::kTagged);
- r.CheckNumberConstant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kWord32, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
+ r.CheckNumberConstant(c, *i);
}
}
{
FOR_UINT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Unsigned32(),
- MachineRepresentation::kTagged);
+ n, MachineRepresentation::kWord32, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kTagged, Truncation::None()));
r.CheckNumberConstant(c, *i);
}
}
@@ -201,49 +219,54 @@
{
FOR_FLOAT64_INPUTS(i) {
Node* n = r.jsgraph()->Float64Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::None(),
- MachineRepresentation::kFloat64);
- CHECK_EQ(n, c);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat64, Truncation::None()));
+ CHECK_EQ(n, c);
}
}
{
FOR_FLOAT64_INPUTS(i) {
Node* n = r.jsgraph()->Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kTagged, Type::None(),
- MachineRepresentation::kFloat64);
- r.CheckFloat64Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kTagged, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat64, Truncation::None()));
+ r.CheckFloat64Constant(c, *i);
}
}
{
FOR_FLOAT32_INPUTS(i) {
Node* n = r.jsgraph()->Float32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat32, Type::None(),
- MachineRepresentation::kFloat64);
- r.CheckFloat64Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat32, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat64, Truncation::None()));
+ r.CheckFloat64Constant(c, *i);
}
}
{
FOR_INT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Signed32(),
- MachineRepresentation::kFloat64);
- r.CheckFloat64Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kWord32, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kFloat64, Truncation::None()));
+ r.CheckFloat64Constant(c, *i);
}
}
{
FOR_UINT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Unsigned32(),
- MachineRepresentation::kFloat64);
+ n, MachineRepresentation::kWord32, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kFloat64, Truncation::None()));
r.CheckFloat64Constant(c, *i);
}
}
@@ -264,30 +287,33 @@
{
FOR_FLOAT32_INPUTS(i) {
Node* n = r.jsgraph()->Float32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat32, Type::None(),
- MachineRepresentation::kFloat32);
- CHECK_EQ(n, c);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat32, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat32, Truncation::None()));
+ CHECK_EQ(n, c);
}
}
{
FOR_FLOAT32_INPUTS(i) {
Node* n = r.jsgraph()->Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kTagged, Type::None(),
- MachineRepresentation::kFloat32);
- r.CheckFloat32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kTagged, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat32, Truncation::None()));
+ r.CheckFloat32Constant(c, *i);
}
}
{
FOR_FLOAT32_INPUTS(i) {
Node* n = r.jsgraph()->Float64Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::None(),
- MachineRepresentation::kFloat32);
- r.CheckFloat32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::None(), use,
+ UseInfo(MachineRepresentation::kFloat32, Truncation::None()));
+ r.CheckFloat32Constant(c, *i);
}
}
@@ -295,9 +321,10 @@
FOR_INT32_INPUTS(i) {
if (!IsFloat32Int32(*i)) continue;
Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Signed32(),
- MachineRepresentation::kFloat32);
+ n, MachineRepresentation::kWord32, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kFloat32, Truncation::None()));
r.CheckFloat32Constant(c, static_cast<float>(*i));
}
}
@@ -306,9 +333,10 @@
FOR_UINT32_INPUTS(i) {
if (!IsFloat32Uint32(*i)) continue;
Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Unsigned32(),
- MachineRepresentation::kFloat32);
+ n, MachineRepresentation::kWord32, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kFloat32, Truncation::None()));
r.CheckFloat32Constant(c, static_cast<float>(*i));
}
}
@@ -321,10 +349,11 @@
{
FOR_INT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Signed32(),
- MachineRepresentation::kWord32);
- r.CheckInt32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kWord32, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
+ r.CheckInt32Constant(c, *i);
}
}
@@ -332,9 +361,10 @@
FOR_INT32_INPUTS(i) {
if (!IsFloat32Int32(*i)) continue;
Node* n = r.jsgraph()->Float32Constant(static_cast<float>(*i));
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat32, Type::Signed32(),
- MachineRepresentation::kWord32);
+ n, MachineRepresentation::kFloat32, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
r.CheckInt32Constant(c, *i);
}
}
@@ -342,19 +372,21 @@
{
FOR_INT32_INPUTS(i) {
Node* n = r.jsgraph()->Float64Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::Signed32(),
- MachineRepresentation::kWord32);
- r.CheckInt32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
+ r.CheckInt32Constant(c, *i);
}
}
{
FOR_INT32_INPUTS(i) {
Node* n = r.jsgraph()->Constant(*i);
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kTagged, Type::Signed32(),
- MachineRepresentation::kWord32);
+ n, MachineRepresentation::kTagged, Type::Signed32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
r.CheckInt32Constant(c, *i);
}
}
@@ -367,10 +399,11 @@
{
FOR_UINT32_INPUTS(i) {
Node* n = r.jsgraph()->Int32Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kWord32, Type::Unsigned32(),
- MachineRepresentation::kWord32);
- r.CheckUint32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kWord32, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
+ r.CheckUint32Constant(c, *i);
}
}
@@ -378,9 +411,10 @@
FOR_UINT32_INPUTS(i) {
if (!IsFloat32Uint32(*i)) continue;
Node* n = r.jsgraph()->Float32Constant(static_cast<float>(*i));
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat32, Type::Unsigned32(),
- MachineRepresentation::kWord32);
+ n, MachineRepresentation::kFloat32, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
r.CheckUint32Constant(c, *i);
}
}
@@ -388,19 +422,21 @@
{
FOR_UINT32_INPUTS(i) {
Node* n = r.jsgraph()->Float64Constant(*i);
- Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kFloat64, Type::Unsigned32(),
- MachineRepresentation::kWord32);
- r.CheckUint32Constant(c, *i);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(
+ n, MachineRepresentation::kFloat64, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
+ r.CheckUint32Constant(c, *i);
}
}
{
FOR_UINT32_INPUTS(i) {
Node* n = r.jsgraph()->Constant(static_cast<double>(*i));
+ Node* use = r.Return(n);
Node* c = r.changer()->GetRepresentationFor(
- n, MachineRepresentation::kTagged, Type::Unsigned32(),
- MachineRepresentation::kWord32);
+ n, MachineRepresentation::kTagged, Type::Unsigned32(), use,
+ UseInfo(MachineRepresentation::kWord32, Truncation::None()));
r.CheckUint32Constant(c, *i);
}
}
@@ -412,7 +448,9 @@
RepresentationChangerTester r;
Node* n = r.Parameter();
- Node* c = r.changer()->GetRepresentationFor(n, from, from_type, to);
+ Node* use = r.Return(n);
+ Node* c = r.changer()->GetRepresentationFor(n, from, from_type, use,
+ UseInfo(to, Truncation::None()));
CHECK_NE(c, n);
CHECK_EQ(expected, c->opcode());
@@ -427,7 +465,9 @@
RepresentationChangerTester r;
Node* n = r.Parameter();
- Node* c1 = r.changer()->GetRepresentationFor(n, from, from_type, to);
+ Node* use = r.Return(n);
+ Node* c1 = r.changer()->GetRepresentationFor(n, from, from_type, use,
+ UseInfo(to, Truncation::None()));
CHECK_NE(c1, n);
CHECK_EQ(expected1, c1->opcode());
@@ -473,7 +513,10 @@
CheckChange(IrOpcode::kChangeTaggedToFloat64, MachineRepresentation::kTagged,
Type::Number(), MachineRepresentation::kFloat64);
CheckChange(IrOpcode::kChangeTaggedToFloat64, MachineRepresentation::kTagged,
- Type::NumberOrUndefined(), MachineRepresentation::kFloat64);
+ Type::Number(), MachineRepresentation::kFloat64);
+ CheckChange(IrOpcode::kTruncateTaggedToFloat64,
+ MachineRepresentation::kTagged, Type::NumberOrUndefined(),
+ MachineRepresentation::kFloat64);
CheckTwoChanges(IrOpcode::kChangeTaggedSignedToInt32,
IrOpcode::kChangeInt32ToFloat64,
MachineRepresentation::kTagged, Type::TaggedSigned(),
diff --git a/test/cctest/compiler/test-run-intrinsics.cc b/test/cctest/compiler/test-run-intrinsics.cc
index 6aa5f39..0ea611b 100644
--- a/test/cctest/compiler/test-run-intrinsics.cc
+++ b/test/cctest/compiler/test-run-intrinsics.cc
@@ -111,37 +111,6 @@
}
-TEST(OneByteSeqStringGetChar) {
- FunctionTester T("(function(a,b) { return %_OneByteSeqStringGetChar(a,b); })",
- flags);
-
- Handle<SeqOneByteString> string =
- T.main_isolate()->factory()->NewRawOneByteString(3).ToHandleChecked();
- string->SeqOneByteStringSet(0, 'b');
- string->SeqOneByteStringSet(1, 'a');
- string->SeqOneByteStringSet(2, 'r');
- T.CheckCall(T.Val('b'), string, T.Val(0.0));
- T.CheckCall(T.Val('a'), string, T.Val(1));
- T.CheckCall(T.Val('r'), string, T.Val(2));
-}
-
-
-TEST(OneByteSeqStringSetChar) {
- FunctionTester T("(function(a,b) { %_OneByteSeqStringSetChar(a,88,b); })",
- flags);
-
- Handle<SeqOneByteString> string =
- T.main_isolate()->factory()->NewRawOneByteString(3).ToHandleChecked();
- string->SeqOneByteStringSet(0, 'b');
- string->SeqOneByteStringSet(1, 'a');
- string->SeqOneByteStringSet(2, 'r');
- T.Call(T.Val(1), string);
- CHECK_EQ('b', string->SeqOneByteStringGet(0));
- CHECK_EQ('X', string->SeqOneByteStringGet(1));
- CHECK_EQ('r', string->SeqOneByteStringGet(2));
-}
-
-
TEST(StringAdd) {
FunctionTester T("(function(a,b) { return %_StringAdd(a,b); })", flags);
@@ -151,15 +120,6 @@
}
-TEST(StringCharAt) {
- FunctionTester T("(function(a,b) { return %_StringCharAt(a,b); })", flags);
-
- T.CheckCall(T.Val("e"), T.Val("huge fan!"), T.Val(3));
- T.CheckCall(T.Val("f"), T.Val("\xE2\x9D\x8A fan!"), T.Val(2));
- T.CheckCall(T.Val(""), T.Val("not a fan!"), T.Val(23));
-}
-
-
TEST(StringCharCodeAt) {
FunctionTester T("(function(a,b) { return %_StringCharCodeAt(a,b); })",
flags);
@@ -197,37 +157,6 @@
}
-TEST(TwoByteSeqStringGetChar) {
- FunctionTester T("(function(a,b) { return %_TwoByteSeqStringGetChar(a,b); })",
- flags);
-
- Handle<SeqTwoByteString> string =
- T.main_isolate()->factory()->NewRawTwoByteString(3).ToHandleChecked();
- string->SeqTwoByteStringSet(0, 'b');
- string->SeqTwoByteStringSet(1, 'a');
- string->SeqTwoByteStringSet(2, 'r');
- T.CheckCall(T.Val('b'), string, T.Val(0.0));
- T.CheckCall(T.Val('a'), string, T.Val(1));
- T.CheckCall(T.Val('r'), string, T.Val(2));
-}
-
-
-TEST(TwoByteSeqStringSetChar) {
- FunctionTester T("(function(a,b) { %_TwoByteSeqStringSetChar(a,88,b); })",
- flags);
-
- Handle<SeqTwoByteString> string =
- T.main_isolate()->factory()->NewRawTwoByteString(3).ToHandleChecked();
- string->SeqTwoByteStringSet(0, 'b');
- string->SeqTwoByteStringSet(1, 'a');
- string->SeqTwoByteStringSet(2, 'r');
- T.Call(T.Val(1), string);
- CHECK_EQ('b', string->SeqTwoByteStringGet(0));
- CHECK_EQ('X', string->SeqTwoByteStringGet(1));
- CHECK_EQ('r', string->SeqTwoByteStringGet(2));
-}
-
-
TEST(ValueOf) {
FunctionTester T("(function(a) { return %_ValueOf(a); })", flags);
diff --git a/test/cctest/compiler/test-run-jscalls.cc b/test/cctest/compiler/test-run-jscalls.cc
index 12566c2..06cfcd2 100644
--- a/test/cctest/compiler/test-run-jscalls.cc
+++ b/test/cctest/compiler/test-run-jscalls.cc
@@ -218,6 +218,7 @@
i::Handle<i::JSFunction> jsfun = Handle<JSFunction>::cast(ofun);
jsfun->set_code(T.function->code());
jsfun->set_shared(T.function->shared());
+ jsfun->set_literals(T.function->literals());
CHECK(context->Global()
->Set(context, v8_str("foo"), v8::Utils::CallableToLocal(jsfun))
.FromJust());
@@ -242,6 +243,7 @@
i::Handle<i::JSFunction> jsfun = Handle<JSFunction>::cast(ofun);
jsfun->set_code(T.function->code());
jsfun->set_shared(T.function->shared());
+ jsfun->set_literals(T.function->literals());
CHECK(context->Global()
->Set(context, v8_str("foo"), v8::Utils::CallableToLocal(jsfun))
.FromJust());
diff --git a/test/cctest/compiler/test-run-machops.cc b/test/cctest/compiler/test-run-machops.cc
index 6d681bc..685918a 100644
--- a/test/cctest/compiler/test-run-machops.cc
+++ b/test/cctest/compiler/test-run-machops.cc
@@ -7,6 +7,7 @@
#include <limits>
#include "src/base/bits.h"
+#include "src/base/ieee754.h"
#include "src/base/utils/random-number-generator.h"
#include "src/codegen.h"
#include "test/cctest/cctest.h"
@@ -3568,6 +3569,12 @@
}
}
+TEST(RunFloat32Neg) {
+ BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
+ if (!m.machine()->Float32Neg().IsSupported()) return;
+ m.Return(m.AddNode(m.machine()->Float32Neg().op(), m.Parameter(0)));
+ FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(-0.0f - *i, m.Call(*i)); }
+}
TEST(RunFloat32Mul) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(),
@@ -3612,6 +3619,12 @@
}
}
+TEST(RunFloat64Neg) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ if (!m.machine()->Float64Neg().IsSupported()) return;
+ m.Return(m.AddNode(m.machine()->Float64Neg().op(), m.Parameter(0)));
+ FOR_FLOAT64_INPUTS(i) { CHECK_FLOAT_EQ(-0.0 - *i, m.Call(*i)); }
+}
TEST(RunFloat64Mul) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
@@ -5483,6 +5496,156 @@
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(std::abs(*i), m.Call(*i)); }
}
+TEST(RunFloat64Atan) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Atan(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0));
+ CHECK_DOUBLE_EQ(0.0, m.Call(0.0));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::atan(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Atan2) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(),
+ MachineType::Float64());
+ m.Return(m.Float64Atan2(m.Parameter(0), m.Parameter(1)));
+ FOR_FLOAT64_INPUTS(i) {
+ FOR_FLOAT64_INPUTS(j) {
+ CHECK_DOUBLE_EQ(ieee754::atan2(*i, *j), m.Call(*i, *j));
+ }
+ }
+}
+
+TEST(RunFloat64Atanh) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Atanh(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), m.Call(1.0));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-1.0));
+ CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0));
+ CHECK_DOUBLE_EQ(0.0, m.Call(0.0));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::atanh(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Cos) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Cos(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::cos(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Exp) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Exp(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK_EQ(0.0, m.Call(-std::numeric_limits<double>::infinity()));
+ CHECK_DOUBLE_EQ(1.0, m.Call(-0.0));
+ CHECK_DOUBLE_EQ(1.0, m.Call(0.0));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::exp(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Expm1) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Expm1(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK_EQ(-1.0, m.Call(-std::numeric_limits<double>::infinity()));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::expm1(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Log) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Log(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
+ CHECK(std::isnan(m.Call(-1.0)));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
+ CHECK_DOUBLE_EQ(0.0, m.Call(1.0));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Log1p) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Log1p(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-1.0));
+ CHECK_DOUBLE_EQ(0.0, m.Call(0.0));
+ CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log1p(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Log2) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Log2(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
+ CHECK(std::isnan(m.Call(-1.0)));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
+ CHECK_DOUBLE_EQ(0.0, m.Call(1.0));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log2(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Log10) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Log10(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
+ CHECK(std::isnan(m.Call(-1.0)));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log10(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Cbrt) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Cbrt(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+ m.Call(std::numeric_limits<double>::infinity()));
+ CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(),
+ m.Call(-std::numeric_limits<double>::infinity()));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::cbrt(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Sin) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Sin(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::sin(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Tan) {
+ BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+ m.Return(m.Float64Tan(m.Parameter(0)));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+ CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::tan(*i), m.Call(*i)); }
+}
static double two_30 = 1 << 30; // 2^30 is a smi boundary.
static double two_52 = two_30 * (1 << 22); // 2^52 is a precision boundary.
diff --git a/test/cctest/compiler/test-run-native-calls.cc b/test/cctest/compiler/test-run-native-calls.cc
index a63cc8a..9c67fd5 100644
--- a/test/cctest/compiler/test-run-native-calls.cc
+++ b/test/cctest/compiler/test-run-native-calls.cc
@@ -18,6 +18,8 @@
namespace internal {
namespace compiler {
+const auto GetRegConfig = RegisterConfiguration::Turbofan;
+
namespace {
typedef float float32;
typedef double float64;
@@ -76,12 +78,8 @@
class RegisterPairs : public Pairs {
public:
RegisterPairs()
- : Pairs(
- 100,
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_general_registers(),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->allocatable_general_codes()) {}
+ : Pairs(100, GetRegConfig()->num_allocatable_general_registers(),
+ GetRegConfig()->allocatable_general_codes()) {}
};
@@ -91,10 +89,14 @@
Float32RegisterPairs()
: Pairs(
100,
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_aliased_double_registers(),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->allocatable_double_codes()) {}
+#if V8_TARGET_ARCH_ARM
+ // TODO(bbudge) Modify wasm linkage to allow use of all float regs.
+ GetRegConfig()->num_allocatable_double_registers() / 2 - 2,
+#else
+ GetRegConfig()->num_allocatable_double_registers(),
+#endif
+ GetRegConfig()->allocatable_double_codes()) {
+ }
};
@@ -102,12 +104,8 @@
class Float64RegisterPairs : public Pairs {
public:
Float64RegisterPairs()
- : Pairs(
- 100,
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_aliased_double_registers(),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->allocatable_double_codes()) {}
+ : Pairs(100, GetRegConfig()->num_allocatable_double_registers(),
+ GetRegConfig()->allocatable_double_codes()) {}
};
@@ -136,7 +134,12 @@
if (IsFloatingPoint(type.representation())) {
// Allocate a floating point register/stack location.
if (fp_offset < fp_count) {
- return LinkageLocation::ForRegister(fp_regs[fp_offset++]);
+ int code = fp_regs[fp_offset++];
+#if V8_TARGET_ARCH_ARM
+ // TODO(bbudge) Modify wasm linkage to allow use of all float regs.
+ if (type.representation() == MachineRepresentation::kFloat32) code *= 2;
+#endif
+ return LinkageLocation::ForRegister(code);
} else {
int offset = -1 - stack_offset;
stack_offset += StackWords(type);
@@ -154,10 +157,7 @@
}
}
int StackWords(MachineType type) {
- // TODO(titzer): hack. float32 occupies 8 bytes on stack.
- int size = IsFloatingPoint(type.representation())
- ? kDoubleSize
- : (1 << ElementSizeLog2Of(type.representation()));
+ int size = 1 << ElementSizeLog2Of(type.representation());
return size <= kPointerSize ? 1 : size / kPointerSize;
}
void Reset() {
@@ -636,15 +636,14 @@
// Separate tests for parallelization.
-#define TEST_INT32_SUB_WITH_RET(x) \
- TEST(Run_Int32Sub_all_allocatable_pairs_##x) { \
- if (x < Register::kNumRegisters && \
- Register::from_code(x).IsAllocatable()) { \
- Test_RunInt32SubWithRet(x); \
- } \
+#define TEST_INT32_SUB_WITH_RET(x) \
+ TEST(Run_Int32Sub_all_allocatable_pairs_##x) { \
+ if (x < Register::kNumRegisters && \
+ GetRegConfig()->IsAllocatableGeneralCode(x)) { \
+ Test_RunInt32SubWithRet(x); \
+ } \
}
-
TEST_INT32_SUB_WITH_RET(0)
TEST_INT32_SUB_WITH_RET(1)
TEST_INT32_SUB_WITH_RET(2)
@@ -692,9 +691,7 @@
base::AccountingAllocator allocator;
Zone zone(&allocator);
int parray[2];
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
pairs.Next(&parray[0], &parray[1], false);
Allocator params(parray, 2, nullptr, 0);
Allocator rets(rarray, 1, nullptr, 0);
@@ -741,14 +738,12 @@
static void Test_Int32_WeightedSum_of_size(int count) {
Int32Signature sig(count);
for (int p0 = 0; p0 < Register::kNumRegisters; p0++) {
- if (Register::from_code(p0).IsAllocatable()) {
+ if (GetRegConfig()->IsAllocatableGeneralCode(p0)) {
base::AccountingAllocator allocator;
Zone zone(&allocator);
int parray[] = {p0};
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
Allocator params(parray, 1, nullptr, 0);
Allocator rets(rarray, 1, nullptr, 0);
RegisterConfig config(params, rets);
@@ -801,12 +796,8 @@
template <int which>
void Test_Int32_Select() {
- int parray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
+ int parray[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
Allocator params(parray, 1, nullptr, 0);
Allocator rets(rarray, 1, nullptr, 0);
RegisterConfig config(params, rets);
@@ -843,14 +834,10 @@
TEST(Int64Select_registers) {
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_general_registers() < 2)
- return;
+ if (GetRegConfig()->num_allocatable_general_registers() < 2) return;
if (kPointerSize < 8) return; // TODO(titzer): int64 on 32-bit platforms
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
ArgsBuffer<int64_t>::Sig sig(2);
RegisterPairs pairs;
@@ -871,14 +858,11 @@
TEST(Float32Select_registers) {
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_double_registers() < 2) {
+ if (GetRegConfig()->num_allocatable_double_registers() < 2) {
return;
}
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
ArgsBuffer<float32>::Sig sig(2);
Float32RegisterPairs pairs;
@@ -899,15 +883,9 @@
TEST(Float64Select_registers) {
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_double_registers() < 2)
- return;
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_general_registers() < 2)
- return;
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ if (GetRegConfig()->num_allocatable_double_registers() < 2) return;
+ if (GetRegConfig()->num_allocatable_general_registers() < 2) return;
+ int rarray[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
ArgsBuffer<float64>::Sig sig(2);
Float64RegisterPairs pairs;
@@ -928,9 +906,7 @@
TEST(Float32Select_stack_params_return_reg) {
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
Allocator params(nullptr, 0, nullptr, 0);
Allocator rets(nullptr, 0, rarray, 1);
RegisterConfig config(params, rets);
@@ -951,9 +927,7 @@
TEST(Float64Select_stack_params_return_reg) {
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
Allocator params(nullptr, 0, nullptr, 0);
Allocator rets(nullptr, 0, rarray, 1);
RegisterConfig config(params, rets);
@@ -1006,9 +980,7 @@
TEST(Float64StackParamsToStackParams) {
- int rarray[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int rarray[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
Allocator params(nullptr, 0, nullptr, 0);
Allocator rets(nullptr, 0, rarray, 1);
@@ -1027,9 +999,7 @@
void MixedParamTest(int start) {
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_double_registers() < 2)
- return;
+ if (GetRegConfig()->num_double_registers() < 2) return;
// TODO(titzer): mix in 64-bit types on all platforms when supported.
#if V8_TARGET_ARCH_32_BIT
@@ -1058,22 +1028,12 @@
const int num_params = static_cast<int>(arraysize(types) - start);
// Build call descriptor
- int parray_gp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(1)};
- int rarray_gp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
- int parray_fp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(1)};
- int rarray_fp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int parray_gp[] = {GetRegConfig()->GetAllocatableGeneralCode(0),
+ GetRegConfig()->GetAllocatableGeneralCode(1)};
+ int rarray_gp[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
+ int parray_fp[] = {GetRegConfig()->GetAllocatableDoubleCode(0),
+ GetRegConfig()->GetAllocatableDoubleCode(1)};
+ int rarray_fp[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
Allocator palloc(parray_gp, 2, parray_fp, 2);
Allocator ralloc(rarray_gp, 1, rarray_fp, 1);
RegisterConfig config(palloc, ralloc);
@@ -1174,29 +1134,17 @@
// Test: Generate with a function f which reserves a stack slot, call an inner
// function g from f which writes into the stack slot of f.
- if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->num_allocatable_double_registers() < 2)
- return;
+ if (GetRegConfig()->num_allocatable_double_registers() < 2) return;
Isolate* isolate = CcTest::InitIsolateOnce();
// Lots of code to generate the build descriptor for the inner function.
- int parray_gp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(1)};
- int rarray_gp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0)};
- int parray_fp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0),
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(1)};
- int rarray_fp[] = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableDoubleCode(0)};
+ int parray_gp[] = {GetRegConfig()->GetAllocatableGeneralCode(0),
+ GetRegConfig()->GetAllocatableGeneralCode(1)};
+ int rarray_gp[] = {GetRegConfig()->GetAllocatableGeneralCode(0)};
+ int parray_fp[] = {GetRegConfig()->GetAllocatableDoubleCode(0),
+ GetRegConfig()->GetAllocatableDoubleCode(1)};
+ int rarray_fp[] = {GetRegConfig()->GetAllocatableDoubleCode(0)};
Allocator palloc(parray_gp, 2, parray_fp, 2);
Allocator ralloc(rarray_gp, 1, rarray_fp, 1);
RegisterConfig config(palloc, ralloc);
diff --git a/test/cctest/compiler/test-simplified-lowering.cc b/test/cctest/compiler/test-simplified-lowering.cc
index 4efb149..b56721e 100644
--- a/test/cctest/compiler/test-simplified-lowering.cc
+++ b/test/cctest/compiler/test-simplified-lowering.cc
@@ -1167,7 +1167,7 @@
Type::Unsigned32());
CheckChangeInsertion(IrOpcode::kChangeFloat64ToTagged, MachineType::Float64(),
- MachineType::AnyTagged());
+ MachineType::AnyTagged(), Type::Number());
CheckChangeInsertion(IrOpcode::kChangeTaggedToFloat64,
MachineType::AnyTagged(), MachineType::Float64(),
Type::Number());
@@ -1258,7 +1258,7 @@
for (size_t i = 0; i < arraysize(ops); i++) {
CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToFloat64,
- IrOpcode::kChangeFloat64ToTagged);
+ IrOpcode::kChangeFloat64ToTagged, Type::Number());
}
}
@@ -1488,8 +1488,9 @@
TEST(InsertChangeForLoadElement) {
// 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(), kNoWriteBarrier};
+ ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
+ Type::Number(), MachineType::Float64(),
+ kNoWriteBarrier};
Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
t.p1, t.start, t.start);
@@ -1505,8 +1506,8 @@
// 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(), kNoWriteBarrier};
+ kTaggedBase, FixedArrayBase::kHeaderSize, Handle<Name>::null(),
+ Type::Number(), MachineType::Float64(), kNoWriteBarrier};
Node* load = t.graph()->NewNode(t.simplified()->LoadField(access), t.p0,
t.start, t.start);
diff --git a/test/cctest/compiler/value-helper.h b/test/cctest/compiler/value-helper.h
index 7d26dba..75d22b4 100644
--- a/test/cctest/compiler/value-helper.h
+++ b/test/cctest/compiler/value-helper.h
@@ -110,7 +110,9 @@
-3.63759e-10f,
-4.30175e-14f,
-5.27385e-15f,
+ -1.5707963267948966f,
-1.48084e-15f,
+ -2.220446049250313e-16f,
-1.05755e-19f,
-3.2995e-21f,
-1.67354e-23f,
@@ -129,6 +131,7 @@
6.25073e-22f,
4.1723e-13f,
1.44343e-09f,
+ 1.5707963267948966f,
5.27004e-08f,
9.48298e-08f,
5.57888e-07f,
@@ -177,6 +180,7 @@
static std::vector<double> float64_vector() {
static const double nan = std::numeric_limits<double>::quiet_NaN();
static const double values[] = {-2e66,
+ -2.220446049250313e-16,
-9223373136366403584.0,
-9223372036854775808.0, // INT64_MIN
-2147483649.5,
@@ -188,6 +192,7 @@
-999.75,
-2e66,
-1.75,
+ -1.5707963267948966,
-1.0,
-0.5,
-0.0,
@@ -198,7 +203,11 @@
0.375,
0.5,
1.0,
+ 1.17549e-38,
+ 1.56657e-37,
+ 1.0000001,
1.25,
+ 1.5707963267948966,
2,
3.1e7,
5.125,
diff --git a/test/cctest/heap/heap-utils.cc b/test/cctest/heap/heap-utils.cc
new file mode 100644
index 0000000..7d4d4bf
--- /dev/null
+++ b/test/cctest/heap/heap-utils.cc
@@ -0,0 +1,158 @@
+// 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 "test/cctest/heap/heap-utils.h"
+
+#include "src/factory.h"
+#include "src/heap/heap-inl.h"
+#include "src/heap/incremental-marking.h"
+#include "src/heap/mark-compact.h"
+#include "src/isolate.h"
+
+namespace v8 {
+namespace internal {
+namespace heap {
+
+void SealCurrentObjects(Heap* heap) {
+ heap->CollectAllGarbage();
+ heap->CollectAllGarbage();
+ heap->mark_compact_collector()->EnsureSweepingCompleted();
+ heap->old_space()->EmptyAllocationInfo();
+ for (Page* page : *heap->old_space()) {
+ page->MarkNeverAllocateForTesting();
+ }
+}
+
+int FixedArrayLenFromSize(int size) {
+ return (size - FixedArray::kHeaderSize) / kPointerSize;
+}
+
+std::vector<Handle<FixedArray>> CreatePadding(Heap* heap, int padding_size,
+ PretenureFlag tenure,
+ int object_size) {
+ std::vector<Handle<FixedArray>> handles;
+ Isolate* isolate = heap->isolate();
+ int allocate_memory;
+ int length;
+ int free_memory = padding_size;
+ if (tenure == i::TENURED) {
+ heap->old_space()->EmptyAllocationInfo();
+ int overall_free_memory = static_cast<int>(heap->old_space()->Available());
+ CHECK(padding_size <= overall_free_memory || overall_free_memory == 0);
+ } else {
+ heap->new_space()->DisableInlineAllocationSteps();
+ int overall_free_memory =
+ static_cast<int>(*heap->new_space()->allocation_limit_address() -
+ *heap->new_space()->allocation_top_address());
+ CHECK(padding_size <= overall_free_memory || overall_free_memory == 0);
+ }
+ while (free_memory > 0) {
+ if (free_memory > object_size) {
+ allocate_memory = object_size;
+ length = FixedArrayLenFromSize(allocate_memory);
+ } else {
+ allocate_memory = free_memory;
+ length = FixedArrayLenFromSize(allocate_memory);
+ if (length <= 0) {
+ // Not enough room to create another fixed array. Let's create a filler.
+ if (free_memory > (2 * kPointerSize)) {
+ heap->CreateFillerObjectAt(
+ *heap->old_space()->allocation_top_address(), free_memory,
+ ClearRecordedSlots::kNo);
+ }
+ break;
+ }
+ }
+ handles.push_back(isolate->factory()->NewFixedArray(length, tenure));
+ CHECK((tenure == NOT_TENURED && heap->InNewSpace(*handles.back())) ||
+ (tenure == TENURED && heap->InOldSpace(*handles.back())));
+ free_memory -= allocate_memory;
+ }
+ return handles;
+}
+
+void AllocateAllButNBytes(v8::internal::NewSpace* space, int extra_bytes,
+ std::vector<Handle<FixedArray>>* out_handles) {
+ 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;
+ std::vector<Handle<FixedArray>> handles =
+ heap::CreatePadding(space->heap(), new_linear_size, i::NOT_TENURED);
+ if (out_handles != nullptr)
+ out_handles->insert(out_handles->end(), handles.begin(), handles.end());
+}
+
+void FillCurrentPage(v8::internal::NewSpace* space,
+ std::vector<Handle<FixedArray>>* out_handles) {
+ heap::AllocateAllButNBytes(space, 0, out_handles);
+}
+
+bool FillUpOnePage(v8::internal::NewSpace* space,
+ std::vector<Handle<FixedArray>>* out_handles) {
+ space->DisableInlineAllocationSteps();
+ int space_remaining = static_cast<int>(*space->allocation_limit_address() -
+ *space->allocation_top_address());
+ if (space_remaining == 0) return false;
+ std::vector<Handle<FixedArray>> handles =
+ heap::CreatePadding(space->heap(), space_remaining, i::NOT_TENURED);
+ if (out_handles != nullptr)
+ out_handles->insert(out_handles->end(), handles.begin(), handles.end());
+ return true;
+}
+
+void SimulateFullSpace(v8::internal::NewSpace* space,
+ std::vector<Handle<FixedArray>>* out_handles) {
+ heap::FillCurrentPage(space, out_handles);
+ while (heap::FillUpOnePage(space, out_handles) || space->AddFreshPage()) {
+ }
+}
+
+void SimulateIncrementalMarking(i::Heap* heap, bool force_completion) {
+ i::MarkCompactCollector* collector = heap->mark_compact_collector();
+ i::IncrementalMarking* marking = heap->incremental_marking();
+ if (collector->sweeping_in_progress()) {
+ collector->EnsureSweepingCompleted();
+ }
+ CHECK(marking->IsMarking() || marking->IsStopped());
+ if (marking->IsStopped()) {
+ heap->StartIncrementalMarking();
+ }
+ CHECK(marking->IsMarking());
+ if (!force_completion) return;
+
+ while (!marking->IsComplete()) {
+ marking->Step(i::MB, i::IncrementalMarking::NO_GC_VIA_STACK_GUARD);
+ if (marking->IsReadyToOverApproximateWeakClosure()) {
+ marking->FinalizeIncrementally();
+ }
+ }
+ CHECK(marking->IsComplete());
+}
+
+void SimulateFullSpace(v8::internal::PagedSpace* space) {
+ space->EmptyAllocationInfo();
+ space->ResetFreeList();
+ space->ClearStats();
+}
+
+void AbandonCurrentlyFreeMemory(PagedSpace* space) {
+ space->EmptyAllocationInfo();
+ for (Page* page : *space) {
+ page->MarkNeverAllocateForTesting();
+ }
+}
+
+void GcAndSweep(Heap* heap, AllocationSpace space) {
+ heap->CollectGarbage(space);
+ if (heap->mark_compact_collector()->sweeping_in_progress()) {
+ heap->mark_compact_collector()->EnsureSweepingCompleted();
+ }
+}
+
+} // namespace heap
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/heap/heap-utils.h b/test/cctest/heap/heap-utils.h
new file mode 100644
index 0000000..e03e6fa
--- /dev/null
+++ b/test/cctest/heap/heap-utils.h
@@ -0,0 +1,51 @@
+// 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.
+
+#ifndef HEAP_HEAP_UTILS_H_
+#define HEAP_HEAP_UTILS_H_
+
+#include "src/heap/heap.h"
+
+namespace v8 {
+namespace internal {
+namespace heap {
+
+void SealCurrentObjects(Heap* heap);
+
+int FixedArrayLenFromSize(int size);
+
+std::vector<Handle<FixedArray>> CreatePadding(
+ Heap* heap, int padding_size, PretenureFlag tenure,
+ int object_size = Page::kMaxRegularHeapObjectSize);
+
+void AllocateAllButNBytes(
+ v8::internal::NewSpace* space, int extra_bytes,
+ std::vector<Handle<FixedArray>>* out_handles = nullptr);
+
+void FillCurrentPage(v8::internal::NewSpace* space,
+ std::vector<Handle<FixedArray>>* out_handles = nullptr);
+
+// Helper function that simulates a full new-space in the heap.
+bool FillUpOnePage(v8::internal::NewSpace* space,
+ std::vector<Handle<FixedArray>>* out_handles = nullptr);
+
+void SimulateFullSpace(v8::internal::NewSpace* space,
+ std::vector<Handle<FixedArray>>* out_handles = nullptr);
+
+// Helper function that simulates many incremental marking steps until
+// marking is completed.
+void SimulateIncrementalMarking(i::Heap* heap, bool force_completion = true);
+
+// Helper function that simulates a full old-space in the heap.
+void SimulateFullSpace(v8::internal::PagedSpace* space);
+
+void AbandonCurrentlyFreeMemory(PagedSpace* space);
+
+void GcAndSweep(Heap* heap, AllocationSpace space);
+
+} // namespace heap
+} // namespace internal
+} // namespace v8
+
+#endif // HEAP_HEAP_UTILS_H_
diff --git a/test/cctest/heap/test-alloc.cc b/test/cctest/heap/test-alloc.cc
index 1b969b2..348ba19 100644
--- a/test/cctest/heap/test-alloc.cc
+++ b/test/cctest/heap/test-alloc.cc
@@ -31,7 +31,7 @@
#include "src/accessors.h"
#include "src/api.h"
#include "test/cctest/heap/heap-tester.h"
-#include "test/cctest/heap/utils-inl.h"
+#include "test/cctest/heap/heap-utils.h"
using namespace v8::internal;
@@ -52,11 +52,11 @@
heap->CopyJSObject(JSObject::cast(object)).ToObjectChecked();
// Old data space.
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
heap->AllocateByteArray(100, TENURED).ToObjectChecked();
// Old pointer space.
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
heap->AllocateFixedArray(10000, TENURED).ToObjectChecked();
// Large object space.
@@ -72,12 +72,12 @@
kLargeObjectSpaceFillerLength, TENURED).ToObjectChecked();
// Map space.
- SimulateFullSpace(heap->map_space());
+ heap::SimulateFullSpace(heap->map_space());
int instance_size = JSObject::kHeaderSize;
heap->AllocateMap(JS_OBJECT_TYPE, instance_size).ToObjectChecked();
// Test that we can allocate in old pointer space and code space.
- SimulateFullSpace(heap->code_space());
+ heap::SimulateFullSpace(heap->code_space());
heap->AllocateFixedArray(100, TENURED).ToObjectChecked();
heap->CopyCode(CcTest::i_isolate()->builtins()->builtin(
Builtins::kIllegal)).ToObjectChecked();
@@ -102,7 +102,7 @@
v8::Local<v8::Context> env = v8::Context::New(CcTest::isolate());
env->Enter();
Handle<Object> o = TestAllocateAfterFailures();
- CHECK(o->IsTrue());
+ CHECK(o->IsTrue(CcTest::i_isolate()));
env->Exit();
}
@@ -211,8 +211,7 @@
const size_t code_range_size = 32*MB;
CcTest::InitializeVM();
CodeRange code_range(reinterpret_cast<Isolate*>(CcTest::isolate()));
- code_range.SetUp(code_range_size +
- kReservedCodeRangePages * v8::base::OS::CommitPageSize());
+ code_range.SetUp(code_range_size);
size_t current_allocated = 0;
size_t total_allocated = 0;
List< ::Block> blocks(1000);
diff --git a/test/cctest/heap/test-array-buffer-tracker.cc b/test/cctest/heap/test-array-buffer-tracker.cc
new file mode 100644
index 0000000..b331f6b
--- /dev/null
+++ b/test/cctest/heap/test-array-buffer-tracker.cc
@@ -0,0 +1,318 @@
+// 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/heap/array-buffer-tracker.h"
+#include "test/cctest/cctest.h"
+#include "test/cctest/heap/heap-utils.h"
+
+namespace {
+
+typedef i::LocalArrayBufferTracker LocalTracker;
+
+bool IsTracked(i::JSArrayBuffer* buf) {
+ return i::ArrayBufferTracker::IsTracked(buf);
+}
+
+} // namespace
+
+namespace v8 {
+namespace internal {
+
+// The following tests make sure that JSArrayBuffer tracking works expected when
+// moving the objects through various spaces during GC phases.
+
+TEST(ArrayBuffer_OnlyMC) {
+ CcTest::InitializeVM();
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ Heap* heap = reinterpret_cast<Isolate*>(isolate)->heap();
+
+ JSArrayBuffer* raw_ab = nullptr;
+ {
+ v8::HandleScope handle_scope(isolate);
+ Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf = v8::Utils::OpenHandle(*ab);
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(IsTracked(*buf));
+ raw_ab = *buf;
+ // Prohibit page from being released.
+ Page::FromAddress(buf->address())->MarkNeverEvacuate();
+ }
+ // 2 GCs are needed because we promote to old space as live, meaning that
+ // we will survive one GC.
+ heap::GcAndSweep(heap, OLD_SPACE);
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(!IsTracked(raw_ab));
+}
+
+TEST(ArrayBuffer_OnlyScavenge) {
+ CcTest::InitializeVM();
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ Heap* heap = reinterpret_cast<Isolate*>(isolate)->heap();
+
+ JSArrayBuffer* raw_ab = nullptr;
+ {
+ v8::HandleScope handle_scope(isolate);
+ Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf = v8::Utils::OpenHandle(*ab);
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(*buf));
+ raw_ab = *buf;
+ // Prohibit page from being released.
+ Page::FromAddress(buf->address())->MarkNeverEvacuate();
+ }
+ // 2 GCs are needed because we promote to old space as live, meaning that
+ // we will survive one GC.
+ heap::GcAndSweep(heap, OLD_SPACE);
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(!IsTracked(raw_ab));
+}
+
+TEST(ArrayBuffer_ScavengeAndMC) {
+ CcTest::InitializeVM();
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ Heap* heap = reinterpret_cast<Isolate*>(isolate)->heap();
+
+ JSArrayBuffer* raw_ab = nullptr;
+ {
+ v8::HandleScope handle_scope(isolate);
+ Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf = v8::Utils::OpenHandle(*ab);
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(*buf));
+ raw_ab = *buf;
+ // Prohibit page from being released.
+ Page::FromAddress(buf->address())->MarkNeverEvacuate();
+ }
+ // 2 GCs are needed because we promote to old space as live, meaning that
+ // we will survive one GC.
+ heap::GcAndSweep(heap, OLD_SPACE);
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(!IsTracked(raw_ab));
+}
+
+TEST(ArrayBuffer_Compaction) {
+ FLAG_manual_evacuation_candidates_selection = true;
+ CcTest::InitializeVM();
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ Heap* heap = reinterpret_cast<Isolate*>(isolate)->heap();
+ heap::AbandonCurrentlyFreeMemory(heap->old_space());
+
+ v8::HandleScope handle_scope(isolate);
+ Local<v8::ArrayBuffer> ab1 = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf1 = v8::Utils::OpenHandle(*ab1);
+ CHECK(IsTracked(*buf1));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ heap::GcAndSweep(heap, NEW_SPACE);
+
+ Page* page_before_gc = Page::FromAddress(buf1->address());
+ page_before_gc->SetFlag(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
+ CHECK(IsTracked(*buf1));
+
+ heap->CollectAllGarbage();
+
+ Page* page_after_gc = Page::FromAddress(buf1->address());
+ CHECK(IsTracked(*buf1));
+
+ CHECK_NE(page_before_gc, page_after_gc);
+}
+
+TEST(ArrayBuffer_UnregisterDuringSweep) {
+// Regular pages in old space (without compaction) are processed concurrently
+// in the sweeper. If we happen to unregister a buffer (either explicitly, or
+// implicitly through e.g. |Externalize|) we need to sync with the sweeper
+// task.
+//
+// Note: This test will will only fail on TSAN configurations.
+
+// Disable verify-heap since it forces sweeping to be completed in the
+// epilogue of the GC.
+#ifdef VERIFY_HEAP
+ i::FLAG_verify_heap = false;
+#endif // VERIFY_HEAP
+
+ CcTest::InitializeVM();
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ Heap* heap = reinterpret_cast<Isolate*>(isolate)->heap();
+ {
+ v8::HandleScope handle_scope(isolate);
+ Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf = v8::Utils::OpenHandle(*ab);
+
+ {
+ v8::HandleScope handle_scope(isolate);
+ // Allocate another buffer on the same page to force processing a
+ // non-empty set of buffers in the last GC.
+ Local<v8::ArrayBuffer> ab2 = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf2 = v8::Utils::OpenHandle(*ab2);
+ CHECK(IsTracked(*buf));
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(*buf));
+ CHECK(IsTracked(*buf));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(*buf));
+ CHECK(IsTracked(*buf2));
+ }
+
+ heap->CollectGarbage(OLD_SPACE);
+ // |Externalize| will cause the buffer to be |Unregister|ed. Without
+ // barriers and proper synchronization this will trigger a data race on
+ // TSAN.
+ v8::ArrayBuffer::Contents contents = ab->Externalize();
+ heap->isolate()->array_buffer_allocator()->Free(contents.Data(),
+ contents.ByteLength());
+ }
+}
+
+TEST(ArrayBuffer_NonLivePromotion) {
+ // The test verifies that the marking state is preserved when promoting
+ // a buffer to old space.
+ CcTest::InitializeVM();
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ Heap* heap = reinterpret_cast<Isolate*>(isolate)->heap();
+
+ JSArrayBuffer* raw_ab = nullptr;
+ {
+ v8::HandleScope handle_scope(isolate);
+ Handle<FixedArray> root =
+ heap->isolate()->factory()->NewFixedArray(1, TENURED);
+ {
+ v8::HandleScope handle_scope(isolate);
+ Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf = v8::Utils::OpenHandle(*ab);
+ root->set(0, *buf); // Buffer that should not be promoted as live.
+ }
+ heap::SimulateIncrementalMarking(heap, false);
+ CHECK(IsTracked(JSArrayBuffer::cast(root->get(0))));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(JSArrayBuffer::cast(root->get(0))));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(JSArrayBuffer::cast(root->get(0))));
+ raw_ab = JSArrayBuffer::cast(root->get(0));
+ root->set(0, heap->undefined_value());
+ heap::SimulateIncrementalMarking(heap, true);
+ // Prohibit page from being released.
+ Page::FromAddress(raw_ab->address())->MarkNeverEvacuate();
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(!IsTracked(raw_ab));
+ }
+}
+
+TEST(ArrayBuffer_LivePromotion) {
+ // The test verifies that the marking state is preserved when promoting
+ // a buffer to old space.
+ CcTest::InitializeVM();
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ Heap* heap = reinterpret_cast<Isolate*>(isolate)->heap();
+
+ JSArrayBuffer* raw_ab = nullptr;
+ {
+ v8::HandleScope handle_scope(isolate);
+ Handle<FixedArray> root =
+ heap->isolate()->factory()->NewFixedArray(1, TENURED);
+ {
+ v8::HandleScope handle_scope(isolate);
+ Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf = v8::Utils::OpenHandle(*ab);
+ root->set(0, *buf); // Buffer that should be promoted as live.
+ }
+ heap::SimulateIncrementalMarking(heap, true);
+ CHECK(IsTracked(JSArrayBuffer::cast(root->get(0))));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(JSArrayBuffer::cast(root->get(0))));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ CHECK(IsTracked(JSArrayBuffer::cast(root->get(0))));
+ raw_ab = JSArrayBuffer::cast(root->get(0));
+ root->set(0, heap->undefined_value());
+ // Prohibit page from being released.
+ Page::FromAddress(raw_ab->address())->MarkNeverEvacuate();
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(IsTracked(raw_ab));
+ }
+}
+
+TEST(ArrayBuffer_SemiSpaceCopyThenPagePromotion) {
+ // The test verifies that the marking state is preserved across semispace
+ // copy.
+ CcTest::InitializeVM();
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ Heap* heap = reinterpret_cast<Isolate*>(isolate)->heap();
+
+ heap::SealCurrentObjects(heap);
+ {
+ v8::HandleScope handle_scope(isolate);
+ Handle<FixedArray> root =
+ heap->isolate()->factory()->NewFixedArray(1, TENURED);
+ {
+ v8::HandleScope handle_scope(isolate);
+ Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf = v8::Utils::OpenHandle(*ab);
+ root->set(0, *buf); // Buffer that should be promoted as live.
+ Page::FromAddress(buf->address())->MarkNeverEvacuate();
+ }
+ std::vector<Handle<FixedArray>> handles;
+ // Make the whole page transition from new->old, getting the buffers
+ // processed in the sweeper (relying on marking information) instead of
+ // processing during newspace evacuation.
+ heap::FillCurrentPage(heap->new_space(), &handles);
+ CHECK(IsTracked(JSArrayBuffer::cast(root->get(0))));
+ heap::GcAndSweep(heap, NEW_SPACE);
+ heap::SimulateIncrementalMarking(heap, true);
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(IsTracked(JSArrayBuffer::cast(root->get(0))));
+ }
+}
+
+UNINITIALIZED_TEST(ArrayBuffer_SemiSpaceCopyMultipleTasks) {
+ if (FLAG_optimize_for_size) return;
+ // Test allocates JSArrayBuffer on different pages before triggering a
+ // full GC that performs the semispace copy. If parallelized, this test
+ // ensures proper synchronization in TSAN configurations.
+ FLAG_min_semi_space_size = 2 * Page::kPageSize / MB;
+ 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();
+
+ Local<v8::ArrayBuffer> ab1 = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf1 = v8::Utils::OpenHandle(*ab1);
+ heap::FillCurrentPage(heap->new_space());
+ Local<v8::ArrayBuffer> ab2 = v8::ArrayBuffer::New(isolate, 100);
+ Handle<JSArrayBuffer> buf2 = v8::Utils::OpenHandle(*ab2);
+ CHECK_NE(Page::FromAddress(buf1->address()),
+ Page::FromAddress(buf2->address()));
+ heap::GcAndSweep(heap, OLD_SPACE);
+ }
+}
+
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/heap/test-compaction.cc b/test/cctest/heap/test-compaction.cc
index b787780..f61f7e1 100644
--- a/test/cctest/heap/test-compaction.cc
+++ b/test/cctest/heap/test-compaction.cc
@@ -4,12 +4,14 @@
#include "test/cctest/cctest.h"
#include "test/cctest/heap/heap-tester.h"
-#include "test/cctest/heap/utils-inl.h"
+#include "test/cctest/heap/heap-utils.h"
namespace v8 {
namespace internal {
-static void CheckInvariantsOfAbortedPage(Page* page) {
+namespace {
+
+void CheckInvariantsOfAbortedPage(Page* page) {
// Check invariants:
// 1) Markbits are cleared
// 2) The page is not marked as evacuation candidate anymore
@@ -19,6 +21,14 @@
CHECK(!page->IsFlagSet(Page::COMPACTION_WAS_ABORTED));
}
+void CheckAllObjectsOnPage(std::vector<Handle<FixedArray>>& handles,
+ Page* page) {
+ for (auto& fixed_array : handles) {
+ CHECK(Page::FromAddress(fixed_array->address()) == page);
+ }
+}
+
+} // namespace
HEAP_TEST(CompactionFullAbortedPage) {
// Test the scenario where we reach OOM during compaction and the whole page
@@ -33,20 +43,19 @@
Heap* heap = isolate->heap();
{
HandleScope scope1(isolate);
- PageIterator it(heap->old_space());
- while (it.has_next()) {
- it.next()->MarkNeverAllocateForTesting();
- }
+
+ heap::SealCurrentObjects(heap);
{
HandleScope scope2(isolate);
CHECK(heap->old_space()->Expand());
auto compaction_page_handles =
- CreatePadding(heap, Page::kAllocatableMemory, TENURED);
+ heap::CreatePadding(heap, Page::kAllocatableMemory, TENURED);
Page* to_be_aborted_page =
Page::FromAddress(compaction_page_handles.front()->address());
to_be_aborted_page->SetFlag(
MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
+ CheckAllObjectsOnPage(compaction_page_handles, to_be_aborted_page);
heap->set_force_oom(true);
heap->CollectAllGarbage();
@@ -72,29 +81,29 @@
FLAG_concurrent_sweeping = false;
FLAG_manual_evacuation_candidates_selection = true;
- const int object_size = 128 * KB;
+ const int objects_per_page = 10;
+ const int object_size = Page::kAllocatableMemory / objects_per_page;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
Heap* heap = isolate->heap();
{
HandleScope scope1(isolate);
- PageIterator it(heap->old_space());
- while (it.has_next()) {
- it.next()->MarkNeverAllocateForTesting();
- }
+
+ heap::SealCurrentObjects(heap);
{
HandleScope scope2(isolate);
// Fill another page with objects of size {object_size} (last one is
// properly adjusted).
CHECK(heap->old_space()->Expand());
- auto compaction_page_handles =
- CreatePadding(heap, Page::kAllocatableMemory, TENURED, object_size);
+ auto compaction_page_handles = heap::CreatePadding(
+ heap, Page::kAllocatableMemory, TENURED, object_size);
Page* to_be_aborted_page =
Page::FromAddress(compaction_page_handles.front()->address());
to_be_aborted_page->SetFlag(
MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
+ CheckAllObjectsOnPage(compaction_page_handles, to_be_aborted_page);
{
// Add another page that is filled with {num_objects} objects of size
@@ -102,8 +111,9 @@
HandleScope scope3(isolate);
CHECK(heap->old_space()->Expand());
const int num_objects = 3;
- std::vector<Handle<FixedArray>> page_to_fill_handles = CreatePadding(
- heap, object_size * num_objects, TENURED, object_size);
+ std::vector<Handle<FixedArray>> page_to_fill_handles =
+ heap::CreatePadding(heap, object_size * num_objects, TENURED,
+ object_size);
Page* page_to_fill =
Page::FromAddress(page_to_fill_handles.front()->address());
@@ -145,7 +155,8 @@
FLAG_concurrent_sweeping = false;
FLAG_manual_evacuation_candidates_selection = true;
- const int object_size = 128 * KB;
+ const int objects_per_page = 10;
+ const int object_size = Page::kAllocatableMemory / objects_per_page;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
@@ -155,10 +166,7 @@
Handle<FixedArray> root_array =
isolate->factory()->NewFixedArray(10, TENURED);
- PageIterator it(heap->old_space());
- while (it.has_next()) {
- it.next()->MarkNeverAllocateForTesting();
- }
+ heap::SealCurrentObjects(heap);
Page* to_be_aborted_page = nullptr;
{
@@ -167,7 +175,8 @@
// properly adjusted).
CHECK(heap->old_space()->Expand());
std::vector<Handle<FixedArray>> compaction_page_handles =
- CreatePadding(heap, Page::kAllocatableMemory, TENURED, object_size);
+ heap::CreatePadding(heap, Page::kAllocatableMemory, TENURED,
+ object_size);
to_be_aborted_page =
Page::FromAddress(compaction_page_handles.front()->address());
to_be_aborted_page->SetFlag(
@@ -176,8 +185,8 @@
compaction_page_handles[i]->set(0, *compaction_page_handles[i - 1]);
}
root_array->set(0, *compaction_page_handles.back());
+ CheckAllObjectsOnPage(compaction_page_handles, to_be_aborted_page);
}
-
{
// Add another page that is filled with {num_objects} objects of size
// {object_size}.
@@ -186,7 +195,7 @@
const int num_objects = 2;
int used_memory = object_size * num_objects;
std::vector<Handle<FixedArray>> page_to_fill_handles =
- CreatePadding(heap, used_memory, TENURED, object_size);
+ heap::CreatePadding(heap, used_memory, TENURED, object_size);
Page* page_to_fill =
Page::FromAddress(page_to_fill_handles.front()->address());
@@ -233,7 +242,8 @@
FLAG_concurrent_sweeping = false;
FLAG_manual_evacuation_candidates_selection = true;
- const int object_size = 128 * KB;
+ const int objects_per_page = 10;
+ const int object_size = Page::kAllocatableMemory / objects_per_page;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
@@ -242,10 +252,7 @@
HandleScope scope1(isolate);
Handle<FixedArray> root_array =
isolate->factory()->NewFixedArray(10, TENURED);
- PageIterator it(heap->old_space());
- while (it.has_next()) {
- it.next()->MarkNeverAllocateForTesting();
- }
+ heap::SealCurrentObjects(heap);
Page* to_be_aborted_page = nullptr;
{
@@ -253,8 +260,8 @@
// Fill another page with objects of size {object_size} (last one is
// properly adjusted).
CHECK(heap->old_space()->Expand());
- auto compaction_page_handles =
- CreatePadding(heap, Page::kAllocatableMemory, TENURED, object_size);
+ auto compaction_page_handles = heap::CreatePadding(
+ heap, Page::kAllocatableMemory, TENURED, object_size);
// Sanity check that we have enough space for linking up arrays.
CHECK_GE(compaction_page_handles.front()->length(), 2);
to_be_aborted_page =
@@ -270,6 +277,7 @@
isolate->factory()->NewFixedArray(1, NOT_TENURED);
CHECK(heap->InNewSpace(*new_space_array));
compaction_page_handles.front()->set(1, *new_space_array);
+ CheckAllObjectsOnPage(compaction_page_handles, to_be_aborted_page);
}
{
@@ -280,7 +288,7 @@
const int num_objects = 2;
int used_memory = object_size * num_objects;
std::vector<Handle<FixedArray>> page_to_fill_handles =
- CreatePadding(heap, used_memory, TENURED, object_size);
+ heap::CreatePadding(heap, used_memory, TENURED, object_size);
Page* page_to_fill =
Page::FromAddress(page_to_fill_handles.front()->address());
diff --git a/test/cctest/heap/test-heap.cc b/test/cctest/heap/test-heap.cc
index ef4b217..524a553 100644
--- a/test/cctest/heap/test-heap.cc
+++ b/test/cctest/heap/test-heap.cc
@@ -44,7 +44,7 @@
#include "src/snapshot/snapshot.h"
#include "test/cctest/cctest.h"
#include "test/cctest/heap/heap-tester.h"
-#include "test/cctest/heap/utils-inl.h"
+#include "test/cctest/heap/heap-utils.h"
#include "test/cctest/test-feedback-vector.h"
@@ -711,6 +711,44 @@
CHECK(WeakPointerCleared);
}
+TEST(DoNotPromoteWhiteObjectsOnScavenge) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ Heap* heap = isolate->heap();
+ Factory* factory = isolate->factory();
+
+ HandleScope scope(isolate);
+ Handle<Object> white = factory->NewStringFromStaticChars("white");
+
+ CHECK(Marking::IsWhite(Marking::MarkBitFrom(HeapObject::cast(*white))));
+
+ heap->CollectGarbage(NEW_SPACE);
+
+ CHECK(heap->InNewSpace(*white));
+}
+
+TEST(PromoteGreyOrBlackObjectsOnScavenge) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ Heap* heap = isolate->heap();
+ Factory* factory = isolate->factory();
+
+ HandleScope scope(isolate);
+ Handle<Object> marked = factory->NewStringFromStaticChars("marked");
+
+ IncrementalMarking* marking = heap->incremental_marking();
+ marking->Stop();
+ heap->StartIncrementalMarking();
+ while (Marking::IsWhite(Marking::MarkBitFrom(HeapObject::cast(*marked)))) {
+ marking->Step(MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD,
+ IncrementalMarking::FORCE_MARKING,
+ IncrementalMarking::DO_NOT_FORCE_COMPLETION);
+ }
+
+ heap->CollectGarbage(NEW_SPACE);
+
+ CHECK(!heap->InNewSpace(*marked));
+}
TEST(BytecodeArray) {
static const uint8_t kRawBytes[] = {0xc3, 0x7e, 0xa5, 0x5a};
@@ -725,7 +763,7 @@
Factory* factory = isolate->factory();
HandleScope scope(isolate);
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
Handle<FixedArray> constant_pool = factory->NewFixedArray(5, TENURED);
for (int i = 0; i < 5; i++) {
Handle<Object> number = factory->NewHeapNumber(i);
@@ -1350,7 +1388,7 @@
// Simulate several GCs that use incremental marking.
const int kAgingThreshold = 6;
for (int i = 0; i < kAgingThreshold; i++) {
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
CcTest::heap()->CollectAllGarbage();
}
CHECK(!function->shared()->is_compiled() || function->IsOptimized());
@@ -1364,8 +1402,9 @@
// Simulate several GCs that use incremental marking but make sure
// the loop breaks once the function is enqueued as a candidate.
for (int i = 0; i < kAgingThreshold; i++) {
- SimulateIncrementalMarking(CcTest::heap());
- if (!function->next_function_link()->IsUndefined()) break;
+ heap::SimulateIncrementalMarking(CcTest::heap());
+ if (!function->next_function_link()->IsUndefined(CcTest::i_isolate()))
+ break;
CcTest::heap()->CollectAllGarbage();
}
@@ -1440,7 +1479,7 @@
// Simulate incremental marking so that the functions are enqueued as
// code flushing candidates. Then kill one of the functions. Finally
// perform a scavenge while incremental marking is still running.
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
*function2.location() = NULL;
CcTest::heap()->CollectGarbage(NEW_SPACE, "test scavenge while marking");
@@ -1494,7 +1533,7 @@
// Simulate incremental marking so that the function is enqueued as
// code flushing candidate.
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
// Enable the debugger and add a breakpoint while incremental marking
// is running so that incremental marking aborts and code flushing is
@@ -1549,7 +1588,7 @@
Handle<JSFunction> g_function = Handle<JSFunction>::cast(g_value);
CHECK(!g_function->is_compiled());
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
CompileRun("%OptimizeFunctionOnNextCall(f); f();");
// g should now have available an optimized function, unmarked by gc. The
@@ -1644,7 +1683,7 @@
int CountNativeContexts() {
int count = 0;
Object* object = CcTest::heap()->native_contexts_list();
- while (!object->IsUndefined()) {
+ while (!object->IsUndefined(CcTest::i_isolate())) {
count++;
object = Context::cast(object)->next_context_link();
}
@@ -1780,7 +1819,7 @@
Heap* heap = isolate->heap();
int count = 0;
Handle<Object> object(heap->native_contexts_list(), isolate);
- while (!object->IsUndefined()) {
+ while (!object->IsUndefined(isolate)) {
count++;
if (count == n) heap->CollectAllGarbage();
object =
@@ -2658,7 +2697,7 @@
CcTest::heap()->StartIncrementalMarking();
// The following calls will increment CcTest::heap()->global_ic_age().
CcTest::isolate()->ContextDisposedNotification();
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
CcTest::heap()->CollectAllGarbage();
CHECK_EQ(CcTest::heap()->global_ic_age(), f->shared()->ic_age());
@@ -2743,12 +2782,13 @@
TEST(IdleNotificationFinishMarking) {
i::FLAG_allow_natives_syntax = true;
CcTest::InitializeVM();
- SimulateFullSpace(CcTest::heap()->old_space());
+ const int initial_gc_count = CcTest::heap()->gc_count();
+ heap::SimulateFullSpace(CcTest::heap()->old_space());
IncrementalMarking* marking = CcTest::heap()->incremental_marking();
marking->Stop();
CcTest::heap()->StartIncrementalMarking();
- CHECK_EQ(CcTest::heap()->gc_count(), 0);
+ CHECK_EQ(CcTest::heap()->gc_count(), initial_gc_count);
// TODO(hpayer): We cannot write proper unit test right now for heap.
// The ideal test would call kMaxIdleMarkingDelayCounter to test the
@@ -2783,7 +2823,7 @@
(v8::base::TimeTicks::HighResolutionNow().ToInternalValue() /
static_cast<double>(v8::base::Time::kMicrosecondsPerSecond)) +
kLongIdleTime);
- CHECK_EQ(CcTest::heap()->gc_count(), 1);
+ CHECK_EQ(CcTest::heap()->gc_count(), initial_gc_count + 1);
}
@@ -2795,7 +2835,7 @@
if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
v8::HandleScope scope(CcTest::isolate());
v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
- SimulateFullSpace(CcTest::heap()->new_space());
+ heap::SimulateFullSpace(CcTest::heap()->new_space());
AlwaysAllocateScope always_allocate(CcTest::i_isolate());
v8::Local<v8::Value> res = CompileRun(
"function c(x) {"
@@ -3270,7 +3310,7 @@
CompileRun("%DebugPrint(root);");
CHECK_EQ(transitions_count, transitions_before);
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
CcTest::heap()->CollectAllGarbage();
// Count number of live transitions after marking. Note that one transition
@@ -3440,7 +3480,7 @@
"root.foo = 0;"
"root = new Object;");
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
// Compile a StoreIC that performs the prepared map transition. This
// will restart incremental marking and should make sure the root is
@@ -3480,7 +3520,7 @@
"root.foo = 0;"
"root = new Object;");
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
// Compile an optimized LStoreNamedField that performs the prepared
// map transition. This will restart incremental marking and should
@@ -3535,28 +3575,29 @@
// Prepare many pages with low live-bytes count.
PagedSpace* old_space = heap->old_space();
- CHECK_EQ(1, old_space->CountTotalPages());
+ const int initial_page_count = old_space->CountTotalPages();
+ const int overall_page_count = number_of_test_pages + initial_page_count;
for (int i = 0; i < number_of_test_pages; i++) {
AlwaysAllocateScope always_allocate(isolate);
- SimulateFullSpace(old_space);
+ heap::SimulateFullSpace(old_space);
factory->NewFixedArray(1, TENURED);
}
- CHECK_EQ(number_of_test_pages + 1, old_space->CountTotalPages());
+ CHECK_EQ(overall_page_count, old_space->CountTotalPages());
// Triggering one GC will cause a lot of garbage to be discovered but
// even spread across all allocated pages.
heap->CollectAllGarbage(Heap::kFinalizeIncrementalMarkingMask,
"triggered for preparation");
- CHECK_GE(number_of_test_pages + 1, old_space->CountTotalPages());
+ CHECK_GE(overall_page_count, old_space->CountTotalPages());
// Triggering subsequent GCs should cause at least half of the pages
// to be released to the OS after at most two cycles.
heap->CollectAllGarbage(Heap::kFinalizeIncrementalMarkingMask,
"triggered by test 1");
- CHECK_GE(number_of_test_pages + 1, old_space->CountTotalPages());
+ CHECK_GE(overall_page_count, old_space->CountTotalPages());
heap->CollectAllGarbage(Heap::kFinalizeIncrementalMarkingMask,
"triggered by test 2");
- CHECK_GE(number_of_test_pages + 1, old_space->CountTotalPages() * 2);
+ CHECK_GE(overall_page_count, old_space->CountTotalPages() * 2);
// Triggering a last-resort GC should cause all pages to be released to the
// OS so that other processes can seize the memory. If we get a failure here
@@ -3566,7 +3607,7 @@
// boots, but if the 20 small arrays don't fit on the first page then that's
// an indication that it is too small.
heap->CollectAllAvailableGarbage("triggered really hard");
- CHECK_EQ(1, old_space->CountTotalPages());
+ CHECK_EQ(initial_page_count, old_space->CountTotalPages());
}
static int forced_gc_counter = 0;
@@ -3639,7 +3680,7 @@
v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
- Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
+ Handle<TypeFeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper feedback_helper(feedback_vector);
int expected_slots = 2;
@@ -3649,7 +3690,7 @@
CHECK(feedback_vector->Get(feedback_helper.slot(slot1))->IsWeakCell());
CHECK(feedback_vector->Get(feedback_helper.slot(slot2))->IsWeakCell());
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
CcTest::heap()->CollectAllGarbage();
CHECK(!WeakCell::cast(feedback_vector->Get(feedback_helper.slot(slot1)))
@@ -3676,7 +3717,7 @@
static void CheckVectorIC(Handle<JSFunction> f, int slot_index,
InlineCacheState desired_state) {
Handle<TypeFeedbackVector> vector =
- Handle<TypeFeedbackVector>(f->shared()->feedback_vector());
+ Handle<TypeFeedbackVector>(f->feedback_vector());
FeedbackVectorHelper helper(vector);
FeedbackVectorSlot slot = helper.slot(slot_index);
if (vector->GetKind(slot) == FeedbackVectorSlotKind::LOAD_IC) {
@@ -3689,16 +3730,6 @@
}
}
-
-static void CheckVectorICCleared(Handle<JSFunction> f, int slot_index) {
- Handle<TypeFeedbackVector> vector =
- Handle<TypeFeedbackVector>(f->shared()->feedback_vector());
- FeedbackVectorSlot slot(slot_index);
- LoadICNexus nexus(vector, slot);
- CHECK(IC::IsCleared(&nexus));
-}
-
-
TEST(IncrementalMarkingPreservesMonomorphicConstructor) {
if (i::FLAG_always_opt) return;
CcTest::InitializeVM();
@@ -3713,54 +3744,15 @@
v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
- Handle<TypeFeedbackVector> vector(f->shared()->feedback_vector());
+ Handle<TypeFeedbackVector> vector(f->feedback_vector());
CHECK(vector->Get(FeedbackVectorSlot(0))->IsWeakCell());
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
CcTest::heap()->CollectAllGarbage();
CHECK(vector->Get(FeedbackVectorSlot(0))->IsWeakCell());
}
-
-TEST(IncrementalMarkingClearsMonomorphicConstructor) {
- if (i::FLAG_always_opt) return;
- CcTest::InitializeVM();
- Isolate* isolate = CcTest::i_isolate();
- v8::HandleScope scope(CcTest::isolate());
- v8::Local<v8::Value> fun1;
- v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
-
- {
- LocalContext env;
- CompileRun("function fun() { this.x = 1; };");
- fun1 = env->Global()->Get(env.local(), v8_str("fun")).ToLocalChecked();
- }
-
- // Prepare function f that contains a monomorphic constructor for object
- // originating from a different native context.
- CHECK(CcTest::global()->Set(ctx, v8_str("fun1"), fun1).FromJust());
- CompileRun(
- "function fun() { this.x = 1; };"
- "function f(o) { return new o(); } f(fun1); f(fun1);");
- Handle<JSFunction> f = Handle<JSFunction>::cast(
- v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
- CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
-
-
- Handle<TypeFeedbackVector> vector(f->shared()->feedback_vector());
- CHECK(vector->Get(FeedbackVectorSlot(0))->IsWeakCell());
-
- // Fire context dispose notification.
- CcTest::isolate()->ContextDisposedNotification();
- SimulateIncrementalMarking(CcTest::heap());
- CcTest::heap()->CollectAllGarbage();
-
- CHECK_EQ(*TypeFeedbackVector::UninitializedSentinel(isolate),
- vector->Get(FeedbackVectorSlot(0)));
-}
-
-
TEST(IncrementalMarkingPreservesMonomorphicIC) {
if (i::FLAG_always_opt) return;
CcTest::InitializeVM();
@@ -3776,45 +3768,12 @@
CheckVectorIC(f, 0, MONOMORPHIC);
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
CcTest::heap()->CollectAllGarbage();
CheckVectorIC(f, 0, MONOMORPHIC);
}
-
-TEST(IncrementalMarkingClearsMonomorphicIC) {
- if (i::FLAG_always_opt) return;
- CcTest::InitializeVM();
- v8::HandleScope scope(CcTest::isolate());
- v8::Local<v8::Value> obj1;
- v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
-
- {
- LocalContext env;
- CompileRun("function fun() { this.x = 1; }; var obj = new fun();");
- obj1 = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
- }
-
- // Prepare function f that contains a monomorphic IC for object
- // originating from a different native context.
- CHECK(CcTest::global()->Set(ctx, v8_str("obj1"), obj1).FromJust());
- CompileRun("function f(o) { return o.x; } f(obj1); f(obj1);");
- Handle<JSFunction> f = Handle<JSFunction>::cast(
- v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
- CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
-
- CheckVectorIC(f, 0, MONOMORPHIC);
-
- // Fire context dispose notification.
- CcTest::isolate()->ContextDisposedNotification();
- SimulateIncrementalMarking(CcTest::heap());
- CcTest::heap()->CollectAllGarbage();
-
- CheckVectorICCleared(f, 0);
-}
-
-
TEST(IncrementalMarkingPreservesPolymorphicIC) {
if (i::FLAG_always_opt) return;
CcTest::InitializeVM();
@@ -3846,14 +3805,13 @@
CheckVectorIC(f, 0, POLYMORPHIC);
// Fire context dispose notification.
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
CcTest::heap()->CollectAllGarbage();
CheckVectorIC(f, 0, POLYMORPHIC);
}
-
-TEST(IncrementalMarkingClearsPolymorphicIC) {
+TEST(ContextDisposeDoesntClearPolymorphicIC) {
if (i::FLAG_always_opt) return;
CcTest::InitializeVM();
v8::HandleScope scope(CcTest::isolate());
@@ -3885,10 +3843,10 @@
// Fire context dispose notification.
CcTest::isolate()->ContextDisposedNotification();
- SimulateIncrementalMarking(CcTest::heap());
+ heap::SimulateIncrementalMarking(CcTest::heap());
CcTest::heap()->CollectAllGarbage();
- CheckVectorICCleared(f, 0);
+ CheckVectorIC(f, 0, POLYMORPHIC);
}
@@ -4057,7 +4015,7 @@
// Simulate incremental marking so that the functions are enqueued as
// code flushing candidates. Then optimize one function. Finally
// finish the GC to complete code flushing.
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
CompileRun("%OptimizeFunctionOnNextCall(g); g(3);");
heap->CollectAllGarbage();
@@ -4103,7 +4061,7 @@
// Simulate incremental marking so that unoptimized code is flushed
// even though it still is cached in the optimized code map.
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
heap->CollectAllGarbage();
// Make a new closure that will get code installed from the code map.
@@ -4171,7 +4129,7 @@
}
// Simulate incremental marking and collect code flushing candidates.
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
CHECK(shared1->code()->gc_metadata() != NULL);
// Optimize function and make sure the unoptimized code is replaced.
@@ -4227,9 +4185,9 @@
array_data->set(0, Smi::FromInt(1));
array_data->set(1, Smi::FromInt(2));
- AllocateAllButNBytes(CcTest::heap()->new_space(),
- JSArray::kSize + AllocationMemento::kSize +
- kPointerSize);
+ heap::AllocateAllButNBytes(
+ CcTest::heap()->new_space(),
+ JSArray::kSize + AllocationMemento::kSize + kPointerSize);
Handle<JSArray> array =
factory->NewJSArrayWithElements(array_data, FAST_SMI_ELEMENTS);
@@ -4302,7 +4260,8 @@
if (!code->is_optimized_code()) return;
}
- Handle<TypeFeedbackVector> vector = handle(shared->feedback_vector());
+ Handle<TypeFeedbackVector> vector =
+ TypeFeedbackVector::New(isolate, handle(shared->feedback_metadata()));
Handle<LiteralsArray> lit =
LiteralsArray::New(isolate, vector, shared->num_literals(), TENURED);
Handle<Context> context(isolate->context());
@@ -4359,7 +4318,8 @@
if (!code->is_optimized_code()) return;
}
- Handle<TypeFeedbackVector> vector = handle(shared->feedback_vector());
+ Handle<TypeFeedbackVector> vector =
+ TypeFeedbackVector::New(isolate, handle(shared->feedback_metadata()));
Handle<LiteralsArray> lit =
LiteralsArray::New(isolate, vector, shared->num_literals(), TENURED);
Handle<Context> context(isolate->context());
@@ -4378,7 +4338,7 @@
HandleScope inner_scope(isolate);
AlwaysAllocateScope always_allocate(isolate);
// Make sure literal is placed on an old-space evacuation candidate.
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
// Make sure there the number of literals is > 0.
Handle<LiteralsArray> lit =
@@ -4393,7 +4353,7 @@
// simulate incremental marking to enqueue optimized code map.
FLAG_manual_evacuation_candidates_selection = true;
evac_page->SetFlag(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
// No matter whether reachable or not, {boomer} is doomed.
Handle<Object> boomer(shared->optimized_code_map(), isolate);
@@ -4590,7 +4550,7 @@
HandleScope scope(isolate);
// Create an object on an evacuation candidate.
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
Handle<FixedArray> lit = isolate->factory()->NewFixedArray(4, TENURED);
Page* evac_page = Page::FromAddress(lit->address());
evac_page->SetFlag(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
@@ -4603,7 +4563,7 @@
CHECK(heap->lo_space()->Contains(*lo));
// Start incremental marking to active write barrier.
- SimulateIncrementalMarking(heap, false);
+ heap::SimulateIncrementalMarking(heap, false);
heap->incremental_marking()->AdvanceIncrementalMarking(
10000000, IncrementalMarking::IdleStepActions());
@@ -4704,7 +4664,7 @@
static int AllocationSitesCount(Heap* heap) {
int count = 0;
for (Object* site = heap->allocation_sites_list();
- !(site->IsUndefined());
+ !(site->IsUndefined(heap->isolate()));
site = AllocationSite::cast(site)->weak_next()) {
count++;
}
@@ -4880,7 +4840,7 @@
if (!isolate->use_crankshaft()) return;
HandleScope outer_scope(heap->isolate());
for (int i = 0; i < 3; i++) {
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
{
LocalContext context;
HandleScope scope(heap->isolate());
@@ -5064,7 +5024,7 @@
// cleared. Now, verify that one additional call with a new function
// allows monomorphicity.
Handle<TypeFeedbackVector> feedback_vector = Handle<TypeFeedbackVector>(
- createObj->shared()->feedback_vector(), CcTest::i_isolate());
+ createObj->feedback_vector(), CcTest::i_isolate());
for (int i = 0; i < 20; i++) {
Object* slot_value = feedback_vector->Get(FeedbackVectorSlot(0));
CHECK(slot_value->IsWeakCell());
@@ -5265,12 +5225,11 @@
return Handle<JSFunction>::cast(obj);
}
-
-void CheckIC(Code* code, Code::Kind kind, SharedFunctionInfo* shared,
- int slot_index, InlineCacheState state) {
+void CheckIC(Handle<JSFunction> function, Code::Kind kind, int slot_index,
+ InlineCacheState state) {
if (kind == Code::LOAD_IC || kind == Code::KEYED_LOAD_IC ||
kind == Code::CALL_IC) {
- TypeFeedbackVector* vector = shared->feedback_vector();
+ TypeFeedbackVector* vector = function->feedback_vector();
FeedbackVectorSlot slot(slot_index);
if (kind == Code::LOAD_IC) {
LoadICNexus nexus(vector, slot);
@@ -5283,9 +5242,10 @@
CHECK_EQ(nexus.StateFromFeedback(), state);
}
} else {
- Code* ic = FindFirstIC(code, kind);
+ Code* ic = FindFirstIC(function->code(), kind);
CHECK(ic->is_inline_cache_stub());
- CHECK(ic->ic_state() == state);
+ CHECK(!IC::ICUseVector(kind));
+ CHECK_EQ(state, IC::StateFromCode(ic));
}
}
@@ -5314,12 +5274,12 @@
CompileRun("(testIC())");
}
heap->CollectAllGarbage();
- CheckIC(loadIC->code(), Code::LOAD_IC, loadIC->shared(), 0, MONOMORPHIC);
+ CheckIC(loadIC, Code::LOAD_IC, 0, MONOMORPHIC);
{
v8::HandleScope scope(CcTest::isolate());
CompileRun("(testIC())");
}
- CheckIC(loadIC->code(), Code::LOAD_IC, loadIC->shared(), 0, MONOMORPHIC);
+ CheckIC(loadIC, Code::LOAD_IC, 0, MONOMORPHIC);
}
@@ -5350,12 +5310,12 @@
CompileRun("(testIC())");
}
heap->CollectAllGarbage();
- CheckIC(loadIC->code(), Code::LOAD_IC, loadIC->shared(), 0, POLYMORPHIC);
+ CheckIC(loadIC, Code::LOAD_IC, 0, POLYMORPHIC);
{
v8::HandleScope scope(CcTest::isolate());
CompileRun("(testIC())");
}
- CheckIC(loadIC->code(), Code::LOAD_IC, loadIC->shared(), 0, POLYMORPHIC);
+ CheckIC(loadIC, Code::LOAD_IC, 0, POLYMORPHIC);
}
@@ -5529,7 +5489,7 @@
Page::FromAddress(objects[i]->address())
->SetFlag(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
}
- SimulateFullSpace(old_space);
+ heap::SimulateFullSpace(old_space);
heap->CollectGarbage(OLD_SPACE);
// If we get this far, we've successfully aborted compaction. Any further
// allocations might trigger OOM.
@@ -5589,7 +5549,7 @@
UNINITIALIZED_TEST(PromotionQueue) {
i::FLAG_expose_gc = true;
- i::FLAG_max_semi_space_size = 2 * (Page::kPageSize / MB);
+ i::FLAG_max_semi_space_size = 2 * Page::kPageSize / MB;
i::FLAG_min_semi_space_size = i::FLAG_max_semi_space_size;
v8::Isolate::CreateParams create_params;
create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
@@ -5642,7 +5602,7 @@
CHECK(i::FLAG_min_semi_space_size * MB == new_space->TotalCapacity());
// Fill-up the first semi-space page.
- FillUpOnePage(new_space);
+ heap::FillUpOnePage(new_space);
// Create a small object to initialize the bump pointer on the second
// semi-space page.
@@ -5651,7 +5611,7 @@
CHECK(heap->InNewSpace(*small));
// Fill-up the second semi-space page.
- FillUpOnePage(new_space);
+ heap::FillUpOnePage(new_space);
// This scavenge will corrupt memory if the promotion queue is not
// evacuated.
@@ -5681,9 +5641,9 @@
// Allocate padding objects in old pointer space so, that object allocated
// afterwards would end at the end of the page.
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
int padding_size = desired_offset - Page::kObjectStartOffset;
- CreatePadding(heap, padding_size, TENURED);
+ heap::CreatePadding(heap, padding_size, TENURED);
Handle<JSObject> o = factory->NewJSObjectFromMap(map1, TENURED);
o->set_properties(*factory->empty_fixed_array());
@@ -5830,11 +5790,11 @@
Handle<WeakCell> weak_cell = AddRetainedMap(isolate, heap);
CHECK(!weak_cell->cleared());
for (int i = 0; i < n; i++) {
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
heap->CollectGarbage(OLD_SPACE);
}
CHECK(!weak_cell->cleared());
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
heap->CollectGarbage(OLD_SPACE);
CHECK(weak_cell->cleared());
}
@@ -5863,7 +5823,7 @@
heap->CollectGarbage(OLD_SPACE);
// Force GC in old space on next addition of retained map.
Map::WeakCellForMap(map);
- SimulateFullSpace(CcTest::heap()->new_space());
+ heap::SimulateFullSpace(CcTest::heap()->new_space());
for (int i = 0; i < 10; i++) {
heap->AddRetainedMap(map);
}
@@ -6146,6 +6106,7 @@
Isolate* isolate = CcTest::i_isolate();
Heap* heap = isolate->heap();
GCTracer* tracer = heap->tracer();
+ tracer->ResetForTesting();
int time1 = 100;
size_t counter1 = 1000;
tracer->SampleAllocation(time1, counter1, 0);
@@ -6169,6 +6130,7 @@
Isolate* isolate = CcTest::i_isolate();
Heap* heap = isolate->heap();
GCTracer* tracer = heap->tracer();
+ tracer->ResetForTesting();
int time1 = 100;
size_t counter1 = 1000;
tracer->SampleAllocation(time1, counter1, 0);
@@ -6190,7 +6152,7 @@
Isolate* isolate = CcTest::i_isolate();
Object* message =
*reinterpret_cast<Object**>(isolate->pending_message_obj_address());
- CHECK(message->IsTheHole());
+ CHECK(message->IsTheHole(isolate));
}
@@ -6304,6 +6266,7 @@
Isolate* isolate = CcTest::i_isolate();
Heap* heap = isolate->heap();
GCTracer* tracer = heap->tracer();
+ tracer->ResetForTesting();
int time1 = 100;
size_t counter1 = 1000;
tracer->SampleAllocation(time1, 0, counter1);
@@ -6328,6 +6291,7 @@
Isolate* isolate = CcTest::i_isolate();
Heap* heap = isolate->heap();
GCTracer* tracer = heap->tracer();
+ tracer->ResetForTesting();
int time1 = 100;
size_t counter1 = 1000;
tracer->SampleAllocation(time1, counter1, counter1);
@@ -6445,7 +6409,7 @@
parent.Reset(isolate, v8::Object::New(isolate));
child.Reset(isolate, v8::Object::New(isolate));
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
heap->CollectGarbage(OLD_SPACE);
{
UniqueId id = MakeUniqueId(parent);
@@ -6504,7 +6468,7 @@
array->set(i, *number);
}
heap->CollectGarbage(OLD_SPACE);
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
heap->RightTrimFixedArray<Heap::CONCURRENT_TO_SWEEPER>(*array, N - 1);
heap->mark_compact_collector()->EnsureSweepingCompleted();
ByteArray* byte_array;
@@ -6587,7 +6551,7 @@
}
}
}
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
for (size_t j = 0; j < arrays.size(); j++) {
heap->RightTrimFixedArray<Heap::CONCURRENT_TO_SWEEPER>(arrays[j], N - 1);
}
@@ -6597,51 +6561,6 @@
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
@@ -6755,5 +6674,61 @@
CHECK_EQ(size_after, size_before + array->Size());
}
+TEST(Regress615489) {
+ FLAG_black_allocation = true;
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Heap* heap = CcTest::heap();
+ Isolate* isolate = heap->isolate();
+ heap->CollectAllGarbage();
+
+ i::MarkCompactCollector* collector = heap->mark_compact_collector();
+ i::IncrementalMarking* marking = heap->incremental_marking();
+ if (collector->sweeping_in_progress()) {
+ collector->EnsureSweepingCompleted();
+ }
+ CHECK(marking->IsMarking() || marking->IsStopped());
+ if (marking->IsStopped()) {
+ heap->StartIncrementalMarking();
+ }
+ CHECK(marking->IsMarking());
+ marking->StartBlackAllocationForTesting();
+ {
+ AlwaysAllocateScope always_allocate(CcTest::i_isolate());
+ v8::HandleScope inner(CcTest::isolate());
+ isolate->factory()->NewFixedArray(500, TENURED)->Size();
+ }
+ while (!marking->IsComplete()) {
+ marking->Step(i::MB, i::IncrementalMarking::NO_GC_VIA_STACK_GUARD);
+ if (marking->IsReadyToOverApproximateWeakClosure()) {
+ marking->FinalizeIncrementally();
+ }
+ }
+ CHECK(marking->IsComplete());
+ intptr_t size_before = heap->SizeOfObjects();
+ CcTest::heap()->CollectAllGarbage();
+ intptr_t size_after = heap->SizeOfObjects();
+ // Live size does not increase after garbage collection.
+ CHECK_LE(size_after, size_before);
+}
+
+TEST(Regress618958) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Heap* heap = CcTest::heap();
+ bool isolate_is_locked = true;
+ heap->update_external_memory(100 * MB);
+ int mark_sweep_count_before = heap->ms_count();
+ heap->MemoryPressureNotification(MemoryPressureLevel::kCritical,
+ isolate_is_locked);
+ int mark_sweep_count_after = heap->ms_count();
+ int mark_sweeps_performed = mark_sweep_count_after - mark_sweep_count_before;
+ // The memory pressuer handler either performed two GCs or performed one and
+ // started incremental marking.
+ CHECK(mark_sweeps_performed == 2 ||
+ (mark_sweeps_performed == 1 &&
+ !heap->incremental_marking()->IsStopped()));
+}
+
} // namespace internal
} // namespace v8
diff --git a/test/cctest/heap/test-incremental-marking.cc b/test/cctest/heap/test-incremental-marking.cc
index 74cbf2c..59697a9 100644
--- a/test/cctest/heap/test-incremental-marking.cc
+++ b/test/cctest/heap/test-incremental-marking.cc
@@ -19,8 +19,7 @@
#include "src/full-codegen/full-codegen.h"
#include "src/global-handles.h"
#include "test/cctest/cctest.h"
-#include "test/cctest/heap/utils-inl.h"
-
+#include "test/cctest/heap/heap-utils.h"
using v8::IdleTask;
using v8::Task;
@@ -120,7 +119,7 @@
v8::Platform* old_platform = i::V8::GetCurrentPlatform();
MockPlatform platform(old_platform);
i::V8::SetPlatformForTesting(&platform);
- SimulateFullSpace(CcTest::heap()->old_space());
+ i::heap::SimulateFullSpace(CcTest::heap()->old_space());
i::IncrementalMarking* marking = CcTest::heap()->incremental_marking();
marking->Stop();
marking->Start();
@@ -145,7 +144,7 @@
v8::Platform* old_platform = i::V8::GetCurrentPlatform();
MockPlatform platform(old_platform);
i::V8::SetPlatformForTesting(&platform);
- SimulateFullSpace(CcTest::heap()->old_space());
+ i::heap::SimulateFullSpace(CcTest::heap()->old_space());
CcTest::heap()->CollectAllGarbage();
i::IncrementalMarking* marking = CcTest::heap()->incremental_marking();
marking->Stop();
@@ -171,7 +170,7 @@
v8::Platform* old_platform = i::V8::GetCurrentPlatform();
MockPlatform platform(old_platform);
i::V8::SetPlatformForTesting(&platform);
- SimulateFullSpace(CcTest::heap()->old_space());
+ i::heap::SimulateFullSpace(CcTest::heap()->old_space());
i::IncrementalMarking* marking = CcTest::heap()->incremental_marking();
marking->Stop();
marking->Start();
diff --git a/test/cctest/heap/test-mark-compact.cc b/test/cctest/heap/test-mark-compact.cc
index 2115f1c..1e5d30d 100644
--- a/test/cctest/heap/test-mark-compact.cc
+++ b/test/cctest/heap/test-mark-compact.cc
@@ -43,8 +43,7 @@
#include "src/global-handles.h"
#include "test/cctest/cctest.h"
#include "test/cctest/heap/heap-tester.h"
-#include "test/cctest/heap/utils-inl.h"
-
+#include "test/cctest/heap/heap-utils.h"
using namespace v8::internal;
using v8::Just;
@@ -76,58 +75,49 @@
DeleteArray(mem);
}
-
-HEAP_TEST(Promotion) {
+TEST(Promotion) {
CcTest::InitializeVM();
- Heap* heap = CcTest::heap();
- heap->ConfigureHeap(1, 1, 1, 0);
+ Isolate* isolate = CcTest::i_isolate();
+ {
+ v8::HandleScope sc(CcTest::isolate());
+ Heap* heap = isolate->heap();
- v8::HandleScope sc(CcTest::isolate());
+ heap::SealCurrentObjects(heap);
- // Allocate a fixed array in the new space.
- int array_length =
- (Page::kMaxRegularHeapObjectSize - FixedArray::kHeaderSize) /
- (4 * kPointerSize);
- Object* obj = heap->AllocateFixedArray(array_length).ToObjectChecked();
- Handle<FixedArray> array(FixedArray::cast(obj));
+ int array_length =
+ heap::FixedArrayLenFromSize(Page::kMaxRegularHeapObjectSize);
+ Handle<FixedArray> array = isolate->factory()->NewFixedArray(array_length);
- // Array should be in the new space.
- CHECK(heap->InSpace(*array, NEW_SPACE));
-
- // Call mark compact GC, so array becomes an old object.
- heap->CollectAllGarbage();
- heap->CollectAllGarbage();
-
- // Array now sits in the old space
- CHECK(heap->InSpace(*array, OLD_SPACE));
+ // Array should be in the new space.
+ CHECK(heap->InSpace(*array, NEW_SPACE));
+ heap->CollectAllGarbage();
+ heap->CollectAllGarbage();
+ CHECK(heap->InSpace(*array, OLD_SPACE));
+ }
}
-
HEAP_TEST(NoPromotion) {
CcTest::InitializeVM();
- Heap* heap = CcTest::heap();
- heap->ConfigureHeap(1, 1, 1, 0);
+ Isolate* isolate = CcTest::i_isolate();
+ {
+ v8::HandleScope sc(CcTest::isolate());
+ Heap* heap = isolate->heap();
- v8::HandleScope sc(CcTest::isolate());
+ heap::SealCurrentObjects(heap);
- // Allocate a big fixed array in the new space.
- int array_length =
- (Page::kMaxRegularHeapObjectSize - FixedArray::kHeaderSize) /
- (2 * kPointerSize);
- Object* obj = heap->AllocateFixedArray(array_length).ToObjectChecked();
- Handle<FixedArray> array(FixedArray::cast(obj));
+ int array_length =
+ heap::FixedArrayLenFromSize(Page::kMaxRegularHeapObjectSize);
+ Handle<FixedArray> array = isolate->factory()->NewFixedArray(array_length);
- // Array should be in the new space.
- CHECK(heap->InSpace(*array, NEW_SPACE));
-
- // Simulate a full old space to make promotion fail.
- SimulateFullSpace(heap->old_space());
-
- // Call mark compact GC, and it should pass.
- heap->CollectGarbage(OLD_SPACE);
+ heap->set_force_oom(true);
+ // Array should be in the new space.
+ CHECK(heap->InSpace(*array, NEW_SPACE));
+ heap->CollectAllGarbage();
+ heap->CollectAllGarbage();
+ CHECK(heap->InSpace(*array, NEW_SPACE));
+ }
}
-
HEAP_TEST(MarkCompactCollector) {
FLAG_incremental_marking = false;
FLAG_retain_maps_for_n_gc = 0;
diff --git a/test/cctest/heap/test-page-promotion.cc b/test/cctest/heap/test-page-promotion.cc
new file mode 100644
index 0000000..4ec2e2a
--- /dev/null
+++ b/test/cctest/heap/test-page-promotion.cc
@@ -0,0 +1,129 @@
+// 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/heap/array-buffer-tracker.h"
+#include "test/cctest/cctest.h"
+#include "test/cctest/heap/heap-utils.h"
+
+namespace {
+
+v8::Isolate* NewIsolateForPagePromotion() {
+ i::FLAG_page_promotion = true;
+ i::FLAG_page_promotion_threshold = 0; // %
+ i::FLAG_min_semi_space_size = 8 * (i::Page::kPageSize / i::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);
+ return isolate;
+}
+
+} // namespace
+
+namespace v8 {
+namespace internal {
+
+UNINITIALIZED_TEST(PagePromotion_NewToOld) {
+ v8::Isolate* isolate = NewIsolateForPagePromotion();
+ 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;
+ heap::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());
+ // To perform a sanity check on live bytes we need to mark the heap.
+ 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::GcAndSweep(heap, OLD_SPACE);
+ CHECK(!heap->new_space()->ContainsSlow(first_page->address()));
+ CHECK(heap->old_space()->ContainsSlow(first_page->address()));
+ }
+}
+
+UNINITIALIZED_TEST(PagePromotion_NewToNew) {
+ v8::Isolate* isolate = NewIsolateForPagePromotion();
+ Isolate* i_isolate = reinterpret_cast<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;
+ heap::SimulateFullSpace(heap->new_space(), &handles);
+ CHECK_GT(handles.size(), 0u);
+ // Last object in handles should definitely be on the last page which does
+ // not contain the age mark.
+ Handle<FixedArray> last_object = handles.back();
+ Page* to_be_promoted_page = Page::FromAddress(last_object->address());
+ CHECK(to_be_promoted_page->Contains(last_object->address()));
+ CHECK(heap->new_space()->ToSpaceContainsSlow(last_object->address()));
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(heap->new_space()->ToSpaceContainsSlow(last_object->address()));
+ CHECK(to_be_promoted_page->Contains(last_object->address()));
+ }
+}
+
+UNINITIALIZED_TEST(PagePromotion_NewToNewJSArrayBuffer) {
+ // Test makes sure JSArrayBuffer backing stores are still tracked after
+ // new-to-new promotion.
+ v8::Isolate* isolate = NewIsolateForPagePromotion();
+ Isolate* i_isolate = reinterpret_cast<Isolate*>(isolate);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Context::New(isolate)->Enter();
+ Heap* heap = i_isolate->heap();
+
+ // Fill the current page which potentially contains the age mark.
+ heap::FillCurrentPage(heap->new_space());
+
+ // Allocate a buffer we would like to check against.
+ Handle<JSArrayBuffer> buffer =
+ i_isolate->factory()->NewJSArrayBuffer(SharedFlag::kNotShared);
+ JSArrayBuffer::SetupAllocatingData(buffer, i_isolate, 100);
+ std::vector<Handle<FixedArray>> handles;
+ // Simulate a full space, filling the interesting page with live objects.
+ heap::SimulateFullSpace(heap->new_space(), &handles);
+ CHECK_GT(handles.size(), 0u);
+ // Last object in handles should definitely be on the last page which does
+ // not contain the age mark.
+ Handle<FixedArray> first_object = handles.front();
+ Page* to_be_promoted_page = Page::FromAddress(first_object->address());
+ CHECK(to_be_promoted_page->Contains(first_object->address()));
+ CHECK(to_be_promoted_page->Contains(buffer->address()));
+ CHECK(heap->new_space()->ToSpaceContainsSlow(first_object->address()));
+ CHECK(heap->new_space()->ToSpaceContainsSlow(buffer->address()));
+ heap::GcAndSweep(heap, OLD_SPACE);
+ CHECK(heap->new_space()->ToSpaceContainsSlow(first_object->address()));
+ CHECK(heap->new_space()->ToSpaceContainsSlow(buffer->address()));
+ CHECK(to_be_promoted_page->Contains(first_object->address()));
+ CHECK(to_be_promoted_page->Contains(buffer->address()));
+ CHECK(ArrayBufferTracker::IsTracked(*buffer));
+ }
+}
+
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/heap/test-spaces.cc b/test/cctest/heap/test-spaces.cc
index da364c5..2328518 100644
--- a/test/cctest/heap/test-spaces.cc
+++ b/test/cctest/heap/test-spaces.cc
@@ -32,7 +32,6 @@
#include "src/v8.h"
#include "test/cctest/cctest.h"
#include "test/cctest/heap/heap-tester.h"
-#include "test/cctest/heap/utils-inl.h"
namespace v8 {
namespace internal {
@@ -203,36 +202,32 @@
TEST(Regress3540) {
Isolate* isolate = CcTest::i_isolate();
Heap* heap = isolate->heap();
- const int pageSize = Page::kPageSize;
MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
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;
- if (!code_range->SetUp(
- code_range_size +
- RoundUp(v8::base::OS::CommitPageSize() * kReservedCodeRangePages,
- MemoryChunk::kAlignment) +
- v8::internal::MemoryAllocator::CodePageAreaSize())) {
+ size_t code_range_size =
+ kMinimumCodeRangeSize > 0 ? kMinimumCodeRangeSize : 3 * Page::kPageSize;
+ if (!code_range->SetUp(code_range_size)) {
return;
}
Address address;
size_t size;
- size_t request_size = code_range_size - 2 * pageSize;
+ size_t request_size = code_range_size - Page::kPageSize;
address = code_range->AllocateRawMemory(
request_size, request_size - (2 * MemoryAllocator::CodePageGuardSize()),
&size);
- CHECK(address != NULL);
+ CHECK_NOT_NULL(address);
Address null_address;
size_t null_size;
- request_size = code_range_size - pageSize;
+ request_size = code_range_size - Page::kPageSize;
null_address = code_range->AllocateRawMemory(
request_size, request_size - (2 * MemoryAllocator::CodePageGuardSize()),
&null_size);
- CHECK(null_address == NULL);
+ CHECK_NULL(null_address);
code_range->FreeRawMemory(address, size);
delete code_range;
@@ -281,8 +276,8 @@
NOT_EXECUTABLE);
delete code_range;
- // Without CodeRange.
- code_range = NULL;
+ // Without a valid CodeRange, i.e., omitting SetUp.
+ code_range = new CodeRange(isolate);
VerifyMemoryChunk(isolate,
heap,
code_range,
@@ -298,6 +293,7 @@
initial_commit_area_size,
second_commit_area_size,
NOT_EXECUTABLE);
+ delete code_range;
}
}
@@ -489,7 +485,15 @@
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
if (!isolate->snapshot_available()) return;
- if (Snapshot::EmbedsScript(isolate)) return;
+ HandleScope scope(isolate);
+ v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
+ // Skip this test on the custom snapshot builder.
+ if (!CcTest::global()
+ ->Get(context, v8_str("assertEquals"))
+ .ToLocalChecked()
+ ->IsUndefined()) {
+ return;
+ }
// If this test fails due to enabling experimental natives that are not part
// of the snapshot, we may need to adjust CalculateFirstPageSizes.
@@ -502,7 +506,6 @@
}
// Executing the empty script gets by with one page per space.
- HandleScope scope(isolate);
CompileRun("/*empty*/");
for (int i = FIRST_PAGED_SPACE; i <= LAST_PAGED_SPACE; i++) {
// Debug code can be very large, so skip CODE_SPACE if we are generating it.
diff --git a/test/cctest/heap/utils-inl.h b/test/cctest/heap/utils-inl.h
deleted file mode 100644
index 0e943b4..0000000
--- a/test/cctest/heap/utils-inl.h
+++ /dev/null
@@ -1,148 +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.
-
-#ifndef HEAP_UTILS_H_
-#define HEAP_UTILS_H_
-
-#include "src/factory.h"
-#include "src/heap/heap-inl.h"
-#include "src/heap/incremental-marking.h"
-#include "src/heap/mark-compact.h"
-#include "src/isolate.h"
-
-
-namespace v8 {
-namespace internal {
-
-static int LenFromSize(int size) {
- return (size - FixedArray::kHeaderSize) / kPointerSize;
-}
-
-
-static inline std::vector<Handle<FixedArray>> CreatePadding(
- Heap* heap, int padding_size, PretenureFlag tenure,
- int object_size = Page::kMaxRegularHeapObjectSize) {
- std::vector<Handle<FixedArray>> handles;
- Isolate* isolate = heap->isolate();
- int allocate_memory;
- int length;
- int free_memory = padding_size;
- if (tenure == i::TENURED) {
- heap->old_space()->EmptyAllocationInfo();
- int overall_free_memory = static_cast<int>(heap->old_space()->Available());
- CHECK(padding_size <= overall_free_memory || overall_free_memory == 0);
- } else {
- heap->new_space()->DisableInlineAllocationSteps();
- int overall_free_memory =
- static_cast<int>(*heap->new_space()->allocation_limit_address() -
- *heap->new_space()->allocation_top_address());
- CHECK(padding_size <= overall_free_memory || overall_free_memory == 0);
- }
- while (free_memory > 0) {
- if (free_memory > object_size) {
- allocate_memory = object_size;
- length = LenFromSize(allocate_memory);
- } else {
- allocate_memory = free_memory;
- length = LenFromSize(allocate_memory);
- if (length <= 0) {
- // Not enough room to create another fixed array. Let's create a filler.
- heap->CreateFillerObjectAt(*heap->old_space()->allocation_top_address(),
- free_memory, ClearRecordedSlots::kNo);
- break;
- }
- }
- handles.push_back(isolate->factory()->NewFixedArray(length, tenure));
- CHECK((tenure == NOT_TENURED && heap->InNewSpace(*handles.back())) ||
- (tenure == TENURED && heap->InOldSpace(*handles.back())));
- free_memory -= allocate_memory;
- }
- return handles;
-}
-
-
-// Helper function that simulates a full new-space in the heap.
-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;
- 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,
- 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;
- 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,
- std::vector<Handle<FixedArray>>* out_handles = nullptr) {
- AllocateAllButNBytes(space, 0, out_handles);
-}
-
-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()) {
- }
-}
-
-
-// Helper function that simulates a full old-space in the heap.
-static inline void SimulateFullSpace(v8::internal::PagedSpace* space) {
- space->EmptyAllocationInfo();
- space->ResetFreeList();
- space->ClearStats();
-}
-
-
-// Helper function that simulates many incremental marking steps until
-// marking is completed.
-static inline void SimulateIncrementalMarking(i::Heap* heap,
- bool force_completion = true) {
- i::MarkCompactCollector* collector = heap->mark_compact_collector();
- i::IncrementalMarking* marking = heap->incremental_marking();
- if (collector->sweeping_in_progress()) {
- collector->EnsureSweepingCompleted();
- }
- CHECK(marking->IsMarking() || marking->IsStopped());
- if (marking->IsStopped()) {
- heap->StartIncrementalMarking();
- }
- CHECK(marking->IsMarking());
- if (!force_completion) return;
-
- while (!marking->IsComplete()) {
- marking->Step(i::MB, i::IncrementalMarking::NO_GC_VIA_STACK_GUARD);
- if (marking->IsReadyToOverApproximateWeakClosure()) {
- marking->FinalizeIncrementally();
- }
- }
- CHECK(marking->IsComplete());
-}
-
-} // namespace internal
-} // namespace v8
-
-#endif // HEAP_UTILS_H_
diff --git a/test/cctest/interpreter/bytecode-expectations-printer.cc b/test/cctest/interpreter/bytecode-expectations-printer.cc
index b0f6236..83f11c6 100644
--- a/test/cctest/interpreter/bytecode-expectations-printer.cc
+++ b/test/cctest/interpreter/bytecode-expectations-printer.cc
@@ -19,6 +19,7 @@
#include "src/interpreter/bytecode-array-iterator.h"
#include "src/interpreter/bytecode-generator.h"
#include "src/interpreter/bytecodes.h"
+#include "src/interpreter/interpreter-intrinsics.h"
#include "src/interpreter/interpreter.h"
#include "src/interpreter/source-position-table.h"
@@ -98,12 +99,6 @@
}
}
-namespace {
-i::Runtime::FunctionId IndexToFunctionId(uint32_t index) {
- return static_cast<i::Runtime::FunctionId>(index);
-}
-} // namespace
-
void BytecodeExpectationsPrinter::PrintBytecodeOperand(
std::ostream& stream, const BytecodeArrayIterator& bytecode_iterator,
const Bytecode& bytecode, int op_index, int parameter_count) const {
@@ -164,9 +159,15 @@
stream << bytecode_iterator.GetRegisterCountOperand(op_index);
break;
case OperandType::kRuntimeId: {
- uint32_t operand = bytecode_iterator.GetRuntimeIdOperand(op_index);
- stream << "Runtime::k"
- << i::Runtime::FunctionForId(IndexToFunctionId(operand))->name;
+ Runtime::FunctionId id =
+ bytecode_iterator.GetRuntimeIdOperand(op_index);
+ stream << "Runtime::k" << i::Runtime::FunctionForId(id)->name;
+ break;
+ }
+ case OperandType::kIntrinsicId: {
+ Runtime::FunctionId id =
+ bytecode_iterator.GetIntrinsicIdOperand(op_index);
+ stream << "Runtime::k" << i::Runtime::FunctionForId(id)->name;
break;
}
default:
diff --git a/test/cctest/interpreter/bytecode_expectations/ArrayLiterals.golden b/test/cctest/interpreter/bytecode_expectations/ArrayLiterals.golden
index 5dcb46b..6bde246 100644
--- a/test/cctest/interpreter/bytecode_expectations/ArrayLiterals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ArrayLiterals.golden
@@ -29,26 +29,24 @@
snippet: "
var a = 1; return [ a, a + 1 ];
"
-frame size: 4
+frame size: 3
parameter count: 1
-bytecode array length: 39
+bytecode array length: 35
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ 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(Ldar), R(0),
+ /* 54 E> */ B(StaKeyedPropertySloppy), 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),
+ /* 57 E> */ B(Add), R(0),
+ B(StaKeyedPropertySloppy), R(2), R(1), U8(1),
B(Ldar), R(2),
/* 66 S> */ B(Return),
]
@@ -80,13 +78,13 @@
snippet: "
var a = 1; return [ [ a, 2 ], [ a + 2 ] ];
"
-frame size: 6
+frame size: 5
parameter count: 1
-bytecode array length: 69
+bytecode array length: 65
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(CreateArrayLiteral), U8(0), U8(2), U8(2),
B(Star), R(2),
B(LdaZero),
@@ -95,23 +93,21 @@
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(0),
+ /* 56 E> */ B(StaKeyedPropertySloppy), R(4), R(3), U8(1),
B(Ldar), R(4),
- B(KeyedStoreICSloppy), R(2), R(1), U8(5),
+ B(StaKeyedPropertySloppy), 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),
+ /* 66 E> */ B(Add), R(0),
+ B(StaKeyedPropertySloppy), R(4), R(3), U8(3),
B(Ldar), R(4),
- B(KeyedStoreICSloppy), R(2), R(1), U8(5),
+ B(StaKeyedPropertySloppy), R(2), R(1), U8(5),
B(Ldar), R(2),
/* 77 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/ArrayLiteralsWide.golden b/test/cctest/interpreter/bytecode_expectations/ArrayLiteralsWide.golden
index a852ad4..9f9a251 100644
--- a/test/cctest/interpreter/bytecode_expectations/ArrayLiteralsWide.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ArrayLiteralsWide.golden
@@ -274,517 +274,517 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 41 S> */ B(LdaConstant), U8(0),
- /* 43 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 51 S> */ B(LdaConstant), U8(1),
- /* 53 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 61 S> */ B(LdaConstant), U8(2),
- /* 63 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 71 S> */ B(LdaConstant), U8(3),
- /* 73 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 81 S> */ B(LdaConstant), U8(4),
- /* 83 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 91 S> */ B(LdaConstant), U8(5),
- /* 93 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 101 S> */ B(LdaConstant), U8(6),
- /* 103 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 111 S> */ B(LdaConstant), U8(7),
- /* 113 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 121 S> */ B(LdaConstant), U8(8),
- /* 123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 131 S> */ B(LdaConstant), U8(9),
- /* 133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 141 S> */ B(LdaConstant), U8(10),
- /* 143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 151 S> */ B(LdaConstant), U8(11),
- /* 153 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 161 S> */ B(LdaConstant), U8(12),
- /* 163 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 171 S> */ B(LdaConstant), U8(13),
- /* 173 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 181 S> */ B(LdaConstant), U8(14),
- /* 183 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 191 S> */ B(LdaConstant), U8(15),
- /* 193 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 201 S> */ B(LdaConstant), U8(16),
- /* 203 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 211 S> */ B(LdaConstant), U8(17),
- /* 213 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 221 S> */ B(LdaConstant), U8(18),
- /* 223 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 231 S> */ B(LdaConstant), U8(19),
- /* 233 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 241 S> */ B(LdaConstant), U8(20),
- /* 243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 251 S> */ B(LdaConstant), U8(21),
- /* 253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 261 S> */ B(LdaConstant), U8(22),
- /* 263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 271 S> */ B(LdaConstant), U8(23),
- /* 273 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 281 S> */ B(LdaConstant), U8(24),
- /* 283 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 291 S> */ B(LdaConstant), U8(25),
- /* 293 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 301 S> */ B(LdaConstant), U8(26),
- /* 303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 311 S> */ B(LdaConstant), U8(27),
- /* 313 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 321 S> */ B(LdaConstant), U8(28),
- /* 323 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 331 S> */ B(LdaConstant), U8(29),
- /* 333 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 341 S> */ B(LdaConstant), U8(30),
- /* 343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 351 S> */ B(LdaConstant), U8(31),
- /* 353 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 361 S> */ B(LdaConstant), U8(32),
- /* 363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 371 S> */ B(LdaConstant), U8(33),
- /* 373 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 381 S> */ B(LdaConstant), U8(34),
- /* 383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 391 S> */ B(LdaConstant), U8(35),
- /* 393 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 401 S> */ B(LdaConstant), U8(36),
- /* 403 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 411 S> */ B(LdaConstant), U8(37),
- /* 413 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 421 S> */ B(LdaConstant), U8(38),
- /* 423 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 431 S> */ B(LdaConstant), U8(39),
- /* 433 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 441 S> */ B(LdaConstant), U8(40),
- /* 443 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 451 S> */ B(LdaConstant), U8(41),
- /* 453 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 461 S> */ B(LdaConstant), U8(42),
- /* 463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 471 S> */ B(LdaConstant), U8(43),
- /* 473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 481 S> */ B(LdaConstant), U8(44),
- /* 483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 491 S> */ B(LdaConstant), U8(45),
- /* 493 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 501 S> */ B(LdaConstant), U8(46),
- /* 503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 511 S> */ B(LdaConstant), U8(47),
- /* 513 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 521 S> */ B(LdaConstant), U8(48),
- /* 523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 531 S> */ B(LdaConstant), U8(49),
- /* 533 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 541 S> */ B(LdaConstant), U8(50),
- /* 543 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 551 S> */ B(LdaConstant), U8(51),
- /* 553 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 561 S> */ B(LdaConstant), U8(52),
- /* 563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 571 S> */ B(LdaConstant), U8(53),
- /* 573 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 581 S> */ B(LdaConstant), U8(54),
- /* 583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 591 S> */ B(LdaConstant), U8(55),
- /* 593 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 601 S> */ B(LdaConstant), U8(56),
- /* 603 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 611 S> */ B(LdaConstant), U8(57),
- /* 613 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 621 S> */ B(LdaConstant), U8(58),
- /* 623 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 631 S> */ B(LdaConstant), U8(59),
- /* 633 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 641 S> */ B(LdaConstant), U8(60),
- /* 643 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 651 S> */ B(LdaConstant), U8(61),
- /* 653 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 661 S> */ B(LdaConstant), U8(62),
- /* 663 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 671 S> */ B(LdaConstant), U8(63),
- /* 673 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 681 S> */ B(LdaConstant), U8(64),
- /* 683 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 691 S> */ B(LdaConstant), U8(65),
- /* 693 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 701 S> */ B(LdaConstant), U8(66),
- /* 703 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 711 S> */ B(LdaConstant), U8(67),
- /* 713 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 721 S> */ B(LdaConstant), U8(68),
- /* 723 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 731 S> */ B(LdaConstant), U8(69),
- /* 733 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 741 S> */ B(LdaConstant), U8(70),
- /* 743 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 751 S> */ B(LdaConstant), U8(71),
- /* 753 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 761 S> */ B(LdaConstant), U8(72),
- /* 763 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 771 S> */ B(LdaConstant), U8(73),
- /* 773 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 781 S> */ B(LdaConstant), U8(74),
- /* 783 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 791 S> */ B(LdaConstant), U8(75),
- /* 793 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 801 S> */ B(LdaConstant), U8(76),
- /* 803 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 811 S> */ B(LdaConstant), U8(77),
- /* 813 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 821 S> */ B(LdaConstant), U8(78),
- /* 823 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 831 S> */ B(LdaConstant), U8(79),
- /* 833 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 841 S> */ B(LdaConstant), U8(80),
- /* 843 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 851 S> */ B(LdaConstant), U8(81),
- /* 853 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 861 S> */ B(LdaConstant), U8(82),
- /* 863 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 871 S> */ B(LdaConstant), U8(83),
- /* 873 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 881 S> */ B(LdaConstant), U8(84),
- /* 883 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 891 S> */ B(LdaConstant), U8(85),
- /* 893 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 901 S> */ B(LdaConstant), U8(86),
- /* 903 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 911 S> */ B(LdaConstant), U8(87),
- /* 913 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 921 S> */ B(LdaConstant), U8(88),
- /* 923 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 931 S> */ B(LdaConstant), U8(89),
- /* 933 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 941 S> */ B(LdaConstant), U8(90),
- /* 943 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 951 S> */ B(LdaConstant), U8(91),
- /* 953 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 961 S> */ B(LdaConstant), U8(92),
- /* 963 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 971 S> */ B(LdaConstant), U8(93),
- /* 973 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 981 S> */ B(LdaConstant), U8(94),
- /* 983 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 991 S> */ B(LdaConstant), U8(95),
- /* 993 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1001 S> */ B(LdaConstant), U8(96),
- /* 1003 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1011 S> */ B(LdaConstant), U8(97),
- /* 1013 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1021 S> */ B(LdaConstant), U8(98),
- /* 1023 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1031 S> */ B(LdaConstant), U8(99),
- /* 1033 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1041 S> */ B(LdaConstant), U8(100),
- /* 1043 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1051 S> */ B(LdaConstant), U8(101),
- /* 1053 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1061 S> */ B(LdaConstant), U8(102),
- /* 1063 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1071 S> */ B(LdaConstant), U8(103),
- /* 1073 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1081 S> */ B(LdaConstant), U8(104),
- /* 1083 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1091 S> */ B(LdaConstant), U8(105),
- /* 1093 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1101 S> */ B(LdaConstant), U8(106),
- /* 1103 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1111 S> */ B(LdaConstant), U8(107),
- /* 1113 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1121 S> */ B(LdaConstant), U8(108),
- /* 1123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1131 S> */ B(LdaConstant), U8(109),
- /* 1133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1141 S> */ B(LdaConstant), U8(110),
- /* 1143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1151 S> */ B(LdaConstant), U8(111),
- /* 1153 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1161 S> */ B(LdaConstant), U8(112),
- /* 1163 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1171 S> */ B(LdaConstant), U8(113),
- /* 1173 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1181 S> */ B(LdaConstant), U8(114),
- /* 1183 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1191 S> */ B(LdaConstant), U8(115),
- /* 1193 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1201 S> */ B(LdaConstant), U8(116),
- /* 1203 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1211 S> */ B(LdaConstant), U8(117),
- /* 1213 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1221 S> */ B(LdaConstant), U8(118),
- /* 1223 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1231 S> */ B(LdaConstant), U8(119),
- /* 1233 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1241 S> */ B(LdaConstant), U8(120),
- /* 1243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1251 S> */ B(LdaConstant), U8(121),
- /* 1253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1261 S> */ B(LdaConstant), U8(122),
- /* 1263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1271 S> */ B(LdaConstant), U8(123),
- /* 1273 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1281 S> */ B(LdaConstant), U8(124),
- /* 1283 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1291 S> */ B(LdaConstant), U8(125),
- /* 1293 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1301 S> */ B(LdaConstant), U8(126),
- /* 1303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1311 S> */ B(LdaConstant), U8(127),
- /* 1313 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1321 S> */ B(LdaConstant), U8(128),
- /* 1323 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1331 S> */ B(LdaConstant), U8(129),
- /* 1333 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1341 S> */ B(LdaConstant), U8(130),
- /* 1343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1351 S> */ B(LdaConstant), U8(131),
- /* 1353 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1361 S> */ B(LdaConstant), U8(132),
- /* 1363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1371 S> */ B(LdaConstant), U8(133),
- /* 1373 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1381 S> */ B(LdaConstant), U8(134),
- /* 1383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1391 S> */ B(LdaConstant), U8(135),
- /* 1393 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1401 S> */ B(LdaConstant), U8(136),
- /* 1403 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1411 S> */ B(LdaConstant), U8(137),
- /* 1413 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1421 S> */ B(LdaConstant), U8(138),
- /* 1423 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1431 S> */ B(LdaConstant), U8(139),
- /* 1433 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1441 S> */ B(LdaConstant), U8(140),
- /* 1443 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1451 S> */ B(LdaConstant), U8(141),
- /* 1453 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1461 S> */ B(LdaConstant), U8(142),
- /* 1463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1471 S> */ B(LdaConstant), U8(143),
- /* 1473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1481 S> */ B(LdaConstant), U8(144),
- /* 1483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1491 S> */ B(LdaConstant), U8(145),
- /* 1493 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1501 S> */ B(LdaConstant), U8(146),
- /* 1503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1511 S> */ B(LdaConstant), U8(147),
- /* 1513 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1521 S> */ B(LdaConstant), U8(148),
- /* 1523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1531 S> */ B(LdaConstant), U8(149),
- /* 1533 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1541 S> */ B(LdaConstant), U8(150),
- /* 1543 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1551 S> */ B(LdaConstant), U8(151),
- /* 1553 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1561 S> */ B(LdaConstant), U8(152),
- /* 1563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1571 S> */ B(LdaConstant), U8(153),
- /* 1573 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1581 S> */ B(LdaConstant), U8(154),
- /* 1583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1591 S> */ B(LdaConstant), U8(155),
- /* 1593 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1601 S> */ B(LdaConstant), U8(156),
- /* 1603 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1611 S> */ B(LdaConstant), U8(157),
- /* 1613 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1621 S> */ B(LdaConstant), U8(158),
- /* 1623 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1631 S> */ B(LdaConstant), U8(159),
- /* 1633 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1641 S> */ B(LdaConstant), U8(160),
- /* 1643 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1651 S> */ B(LdaConstant), U8(161),
- /* 1653 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1661 S> */ B(LdaConstant), U8(162),
- /* 1663 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1671 S> */ B(LdaConstant), U8(163),
- /* 1673 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1681 S> */ B(LdaConstant), U8(164),
- /* 1683 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1691 S> */ B(LdaConstant), U8(165),
- /* 1693 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1701 S> */ B(LdaConstant), U8(166),
- /* 1703 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1711 S> */ B(LdaConstant), U8(167),
- /* 1713 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1721 S> */ B(LdaConstant), U8(168),
- /* 1723 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1731 S> */ B(LdaConstant), U8(169),
- /* 1733 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1741 S> */ B(LdaConstant), U8(170),
- /* 1743 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1751 S> */ B(LdaConstant), U8(171),
- /* 1753 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1761 S> */ B(LdaConstant), U8(172),
- /* 1763 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1771 S> */ B(LdaConstant), U8(173),
- /* 1773 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1781 S> */ B(LdaConstant), U8(174),
- /* 1783 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1791 S> */ B(LdaConstant), U8(175),
- /* 1793 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1801 S> */ B(LdaConstant), U8(176),
- /* 1803 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1811 S> */ B(LdaConstant), U8(177),
- /* 1813 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1821 S> */ B(LdaConstant), U8(178),
- /* 1823 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1831 S> */ B(LdaConstant), U8(179),
- /* 1833 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1841 S> */ B(LdaConstant), U8(180),
- /* 1843 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1851 S> */ B(LdaConstant), U8(181),
- /* 1853 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1861 S> */ B(LdaConstant), U8(182),
- /* 1863 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1871 S> */ B(LdaConstant), U8(183),
- /* 1873 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1881 S> */ B(LdaConstant), U8(184),
- /* 1883 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1891 S> */ B(LdaConstant), U8(185),
- /* 1893 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1901 S> */ B(LdaConstant), U8(186),
- /* 1903 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1911 S> */ B(LdaConstant), U8(187),
- /* 1913 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1921 S> */ B(LdaConstant), U8(188),
- /* 1923 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1931 S> */ B(LdaConstant), U8(189),
- /* 1933 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1941 S> */ B(LdaConstant), U8(190),
- /* 1943 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1951 S> */ B(LdaConstant), U8(191),
- /* 1953 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1961 S> */ B(LdaConstant), U8(192),
- /* 1963 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1971 S> */ B(LdaConstant), U8(193),
- /* 1973 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1981 S> */ B(LdaConstant), U8(194),
- /* 1983 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1991 S> */ B(LdaConstant), U8(195),
- /* 1993 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2001 S> */ B(LdaConstant), U8(196),
- /* 2003 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2011 S> */ B(LdaConstant), U8(197),
- /* 2013 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2021 S> */ B(LdaConstant), U8(198),
- /* 2023 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2031 S> */ B(LdaConstant), U8(199),
- /* 2033 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2041 S> */ B(LdaConstant), U8(200),
- /* 2043 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2051 S> */ B(LdaConstant), U8(201),
- /* 2053 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2061 S> */ B(LdaConstant), U8(202),
- /* 2063 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2071 S> */ B(LdaConstant), U8(203),
- /* 2073 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2081 S> */ B(LdaConstant), U8(204),
- /* 2083 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2091 S> */ B(LdaConstant), U8(205),
- /* 2093 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2101 S> */ B(LdaConstant), U8(206),
- /* 2103 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2111 S> */ B(LdaConstant), U8(207),
- /* 2113 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2121 S> */ B(LdaConstant), U8(208),
- /* 2123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2131 S> */ B(LdaConstant), U8(209),
- /* 2133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2141 S> */ B(LdaConstant), U8(210),
- /* 2143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2151 S> */ B(LdaConstant), U8(211),
- /* 2153 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2161 S> */ B(LdaConstant), U8(212),
- /* 2163 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2171 S> */ B(LdaConstant), U8(213),
- /* 2173 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2181 S> */ B(LdaConstant), U8(214),
- /* 2183 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2191 S> */ B(LdaConstant), U8(215),
- /* 2193 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2201 S> */ B(LdaConstant), U8(216),
- /* 2203 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2211 S> */ B(LdaConstant), U8(217),
- /* 2213 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2221 S> */ B(LdaConstant), U8(218),
- /* 2223 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2231 S> */ B(LdaConstant), U8(219),
- /* 2233 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2241 S> */ B(LdaConstant), U8(220),
- /* 2243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2251 S> */ B(LdaConstant), U8(221),
- /* 2253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2261 S> */ B(LdaConstant), U8(222),
- /* 2263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2271 S> */ B(LdaConstant), U8(223),
- /* 2273 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2281 S> */ B(LdaConstant), U8(224),
- /* 2283 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2291 S> */ B(LdaConstant), U8(225),
- /* 2293 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2301 S> */ B(LdaConstant), U8(226),
- /* 2303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2311 S> */ B(LdaConstant), U8(227),
- /* 2313 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2321 S> */ B(LdaConstant), U8(228),
- /* 2323 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2331 S> */ B(LdaConstant), U8(229),
- /* 2333 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2341 S> */ B(LdaConstant), U8(230),
- /* 2343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2351 S> */ B(LdaConstant), U8(231),
- /* 2353 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2361 S> */ B(LdaConstant), U8(232),
- /* 2363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2371 S> */ B(LdaConstant), U8(233),
- /* 2373 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2381 S> */ B(LdaConstant), U8(234),
- /* 2383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2391 S> */ B(LdaConstant), U8(235),
- /* 2393 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2401 S> */ B(LdaConstant), U8(236),
- /* 2403 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2411 S> */ B(LdaConstant), U8(237),
- /* 2413 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2421 S> */ B(LdaConstant), U8(238),
- /* 2423 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2431 S> */ B(LdaConstant), U8(239),
- /* 2433 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2441 S> */ B(LdaConstant), U8(240),
- /* 2443 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2451 S> */ B(LdaConstant), U8(241),
- /* 2453 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2461 S> */ B(LdaConstant), U8(242),
- /* 2463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2471 S> */ B(LdaConstant), U8(243),
- /* 2473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2481 S> */ B(LdaConstant), U8(244),
- /* 2483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2491 S> */ B(LdaConstant), U8(245),
- /* 2493 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2501 S> */ B(LdaConstant), U8(246),
- /* 2503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2511 S> */ B(LdaConstant), U8(247),
- /* 2513 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2521 S> */ B(LdaConstant), U8(248),
- /* 2523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2531 S> */ B(LdaConstant), U8(249),
- /* 2533 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2541 S> */ B(LdaConstant), U8(250),
- /* 2543 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2551 S> */ B(LdaConstant), U8(251),
- /* 2553 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2561 S> */ B(LdaConstant), U8(252),
- /* 2563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2571 S> */ B(LdaConstant), U8(253),
- /* 2573 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2581 S> */ B(LdaConstant), U8(254),
- /* 2583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2591 S> */ B(LdaConstant), U8(255),
- /* 2593 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2601 S> */ B(Wide), B(CreateArrayLiteral), U16(256), U16(0), U8(3),
/* 2619 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/AssignmentsInBinaryExpression.golden b/test/cctest/interpreter/bytecode_expectations/AssignmentsInBinaryExpression.golden
index c80469b..cdda7f2 100644
--- a/test/cctest/interpreter/bytecode_expectations/AssignmentsInBinaryExpression.golden
+++ b/test/cctest/interpreter/bytecode_expectations/AssignmentsInBinaryExpression.golden
@@ -18,17 +18,17 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 49 S> */ B(LdaSmi), U8(1),
- /* 49 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 52 S> */ B(LdaSmi), U8(2),
- /* 62 E> */ B(Star), R(0),
+ B(Star), R(0),
B(LdaSmi), U8(3),
- /* 69 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(4),
- /* 76 E> */ B(Star), R(0),
+ B(Star), R(0),
B(LdaSmi), U8(5),
- /* 83 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 89 S> */ B(Return),
]
constant pool: [
@@ -44,14 +44,15 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 12
+bytecode array length: 13
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(55),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 57 S> */ B(LdaSmi), U8(100),
- /* 57 E> */ B(Star), R(0),
- /* 57 E> */ B(Star), R(1),
+ B(Star), R(0),
+ B(Star), R(1),
+ /* 65 S> */ B(Nop),
/* 75 S> */ B(Return),
]
constant pool: [
@@ -67,20 +68,21 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 24
+bytecode array length: 26
bytecodes: [
/* 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(0),
+ /* 46 S> */ B(LdaSmi), U8(100),
+ B(Mov), R(0), R(1),
+ B(Star), R(0),
+ /* 57 E> */ 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),
+ B(Star), R(0),
+ /* 69 E> */ B(Add), R(2),
+ B(Star), R(0),
+ /* 77 S> */ B(Nop),
/* 87 S> */ B(Return),
]
constant pool: [
@@ -97,25 +99,24 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 32
+bytecode array length: 29
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(55),
- /* 42 E> */ B(Star), R(0),
+ 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(0),
+ /* 61 E> */ B(Sub), R(0),
B(Star), R(2),
B(LdaSmi), U8(57),
- /* 68 E> */ B(Star), R(0),
- B(Add), R(2),
- /* 48 E> */ B(Star), R(0),
+ B(Star), R(0),
+ /* 68 E> */ B(Add), R(2),
+ B(Star), R(0),
/* 75 S> */ B(ToNumber),
B(Star), R(1),
B(Inc),
- /* 76 E> */ B(Star), R(0),
+ B(Star), R(0),
+ /* 80 S> */ B(Nop),
/* 90 S> */ B(Return),
]
constant pool: [
@@ -131,24 +132,25 @@
"
frame size: 4
parameter count: 1
-bytecode array length: 32
+bytecode array length: 34
bytecodes: [
/* 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(0),
+ /* 76 S> */ B(LdaSmi), U8(1),
+ B(Mov), R(0), R(2),
+ B(Star), R(0),
+ /* 61 E> */ 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(0),
+ /* 71 E> */ 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),
+ B(Star), R(0),
+ /* 81 E> */ B(Add), R(2),
+ B(Star), R(1),
+ /* 87 S> */ B(Nop),
/* 97 S> */ B(Return),
]
constant pool: [
@@ -164,24 +166,25 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 32
+bytecode array length: 34
bytecodes: [
/* 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(0),
+ /* 76 S> */ B(LdaSmi), U8(1),
+ B(Mov), R(0), R(1),
+ B(Star), R(0),
+ /* 61 E> */ 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(0),
+ /* 71 E> */ 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),
+ B(Star), R(0),
+ /* 81 E> */ B(Add), R(1),
+ B(Star), R(0),
+ /* 87 S> */ B(Nop),
/* 97 S> */ B(Return),
]
constant pool: [
@@ -196,43 +199,40 @@
"
frame size: 5
parameter count: 1
-bytecode array length: 70
+bytecode array length: 65
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(10),
- /* 42 E> */ B(Star), R(0),
+ 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(1),
+ /* 54 S> */ B(LdaSmi), U8(1),
+ B(Mov), R(0), R(2),
+ B(Star), R(0),
+ /* 68 E> */ 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),
+ /* 76 E> */ B(Add), R(0),
B(Star), R(4),
B(LdaSmi), U8(2),
- /* 88 E> */ B(Star), R(1),
- B(Mul), R(4),
+ B(Star), R(1),
+ /* 88 E> */ 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(1),
+ /* 98 E> */ 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(0),
+ /* 108 E> */ 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(1),
+ /* 118 E> */ B(Add), R(2),
B(Star), R(3),
- /* 125 E> */ B(Ldar), R(1),
- B(Add), R(3),
+ B(Ldar), R(1),
+ /* 125 E> */ B(Add), R(3),
/* 128 S> */ B(Return),
]
constant pool: [
@@ -251,24 +251,24 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(17),
- /* 42 E> */ B(Star), R(0),
+ 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(Ldar), R(0),
+ /* 57 E> */ 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(Star), R(0),
B(Ldar), R(1),
- B(Add), R(2),
+ /* 63 E> */ B(Add), R(2),
B(Star), R(3),
B(Ldar), R(0),
B(Inc),
- /* 72 E> */ B(Star), R(0),
- B(Add), R(3),
+ B(Star), R(0),
+ /* 72 E> */ 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 6aa50ef..ed81b46 100644
--- a/test/cctest/interpreter/bytecode_expectations/BasicBlockToBoolean.golden
+++ b/test/cctest/interpreter/bytecode_expectations/BasicBlockToBoolean.golden
@@ -11,18 +11,16 @@
snippet: "
var a = 1; if (a || a < 0) { return 1; }
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 21
+bytecode array length: 17
bytecodes: [
/* 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(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanTrue), U8(5),
B(LdaZero),
- /* 56 E> */ B(TestLessThan), R(1),
+ /* 56 E> */ B(TestLessThan), R(0),
B(JumpIfToBooleanFalse), U8(5),
/* 63 S> */ B(LdaSmi), U8(1),
/* 75 S> */ B(Return),
@@ -38,18 +36,16 @@
snippet: "
var a = 1; if (a && a < 0) { return 1; }
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 21
+bytecode array length: 17
bytecodes: [
/* 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(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanFalse), U8(5),
B(LdaZero),
- /* 56 E> */ B(TestLessThan), R(1),
+ /* 56 E> */ B(TestLessThan), R(0),
B(JumpIfToBooleanFalse), U8(5),
/* 63 S> */ B(LdaSmi), U8(1),
/* 75 S> */ B(Return),
@@ -65,23 +61,21 @@
snippet: "
var a = 1; a = (a || a < 0) ? 2 : 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 26
+bytecode array length: 22
bytecodes: [
/* 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(Star), R(0),
+ /* 45 S> */ B(JumpIfToBooleanTrue), U8(5),
B(LdaZero),
- /* 57 E> */ B(TestLessThan), R(1),
+ /* 57 E> */ B(TestLessThan), R(0),
B(JumpIfToBooleanFalse), U8(6),
B(LdaSmi), U8(2),
B(Jump), U8(4),
B(LdaSmi), U8(3),
- /* 47 E> */ B(Star), R(0),
+ B(Star), R(0),
B(LdaUndefined),
/* 71 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/BasicLoops.golden b/test/cctest/interpreter/bytecode_expectations/BasicLoops.golden
index 7936736..8be4e9d 100644
--- a/test/cctest/interpreter/bytecode_expectations/BasicLoops.golden
+++ b/test/cctest/interpreter/bytecode_expectations/BasicLoops.golden
@@ -15,11 +15,12 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 5
+bytecode array length: 6
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
+ /* 88 S> */ B(Nop),
/* 98 S> */ B(Return),
]
constant pool: [
@@ -37,11 +38,12 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 5
+bytecode array length: 6
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
+ /* 77 S> */ B(Nop),
/* 87 S> */ B(Return),
]
constant pool: [
@@ -61,43 +63,34 @@
}
return y;
"
-frame size: 3
+frame size: 2
parameter count: 1
-bytecode array length: 66
+bytecode array length: 48
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ 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),
+ B(Star), R(1),
+ /* 65 S> */ B(LdaSmi), U8(10),
+ /* 65 E> */ B(TestLessThan), R(0),
+ B(JumpIfFalse), U8(33),
/* 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),
+ /* 75 S> */ B(LdaSmi), U8(12),
+ B(Mul), R(1),
+ B(Star), R(1),
+ /* 89 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ /* 102 S> */ B(LdaSmi), U8(3),
+ /* 108 E> */ B(TestEqual), R(0),
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),
+ /* 114 S> */ B(Jump), U8(10),
+ /* 126 S> */ B(LdaSmi), U8(4),
+ /* 132 E> */ B(TestEqual), R(0),
B(JumpIfFalse), U8(4),
/* 138 S> */ B(Jump), U8(4),
- B(Jump), U8(-53),
+ B(Jump), U8(-35),
/* 147 S> */ B(Ldar), R(1),
/* 157 S> */ B(Return),
]
@@ -119,50 +112,38 @@
}
return i;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 79
+bytecode array length: 55
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ 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),
+ /* 62 S> */ B(LdaZero),
+ /* 68 E> */ B(TestLessThan), R(0),
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),
+ /* 73 S> */ B(Jump), U8(40),
+ /* 85 S> */ B(LdaSmi), U8(3),
+ /* 91 E> */ B(TestEqual), R(0),
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),
+ /* 97 S> */ B(Jump), U8(34),
+ /* 106 S> */ B(LdaSmi), U8(4),
+ /* 112 E> */ B(TestEqual), R(0),
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),
+ /* 118 S> */ B(Jump), U8(26),
+ /* 127 S> */ B(LdaSmi), U8(10),
+ /* 133 E> */ B(TestEqual), R(0),
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),
+ /* 140 S> */ B(Jump), U8(16),
+ /* 152 S> */ B(LdaSmi), U8(5),
+ /* 158 E> */ B(TestEqual), R(0),
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),
+ /* 164 S> */ B(Jump), U8(10),
+ /* 173 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ B(Jump), U8(-46),
/* 186 S> */ B(Ldar), R(0),
/* 196 S> */ B(Return),
]
@@ -184,39 +165,31 @@
}
return i;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 57
+bytecode array length: 41
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ 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),
+ /* 71 S> */ B(LdaSmi), U8(3),
+ /* 71 E> */ B(TestLessThan), R(0),
+ B(JumpIfFalse), U8(19),
/* 62 E> */ B(StackCheck),
- /* 82 S> */ B(Ldar), R(0),
- B(Star), R(1),
- B(LdaSmi), U8(2),
- /* 88 E> */ B(TestEqual), R(1),
+ /* 82 S> */ B(LdaSmi), U8(2),
+ /* 88 E> */ B(TestEqual), R(0),
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),
+ /* 94 S> */ B(Jump), U8(10),
+ /* 105 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ B(Jump), U8(-21),
+ /* 122 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
/* 135 S> */ B(Jump), U8(4),
- B(Jump), U8(-48),
+ B(Jump), U8(-32),
/* 144 S> */ B(Ldar), R(0),
/* 154 S> */ B(Return),
]
@@ -235,29 +208,25 @@
}
return y;
"
-frame size: 3
+frame size: 2
parameter count: 1
-bytecode array length: 39
+bytecode array length: 31
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(10),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 54 S> */ B(LdaSmi), U8(1),
- /* 54 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 64 S> */ B(Ldar), R(0),
- B(JumpIfToBooleanFalse), U8(25),
+ B(JumpIfToBooleanFalse), U8(17),
/* 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),
+ /* 71 S> */ B(LdaSmi), U8(12),
+ B(Mul), R(1),
+ B(Star), R(1),
+ /* 85 S> */ B(LdaSmi), U8(1),
+ B(Sub), R(0),
+ B(Star), R(0),
+ B(Jump), U8(-17),
/* 98 S> */ B(Ldar), R(1),
/* 108 S> */ B(Return),
]
@@ -277,43 +246,33 @@
} while (x < 10);
return y;
"
-frame size: 3
+frame size: 2
parameter count: 1
-bytecode array length: 66
+bytecode array length: 46
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 53 S> */ B(LdaSmi), U8(1),
- /* 53 E> */ B(Star), R(1),
+ 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),
+ /* 63 S> */ B(LdaSmi), U8(10),
+ B(Mul), R(1),
+ B(Star), R(1),
+ /* 77 S> */ B(LdaSmi), U8(5),
+ /* 83 E> */ B(TestEqual), R(0),
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),
+ /* 89 S> */ B(Jump), U8(22),
+ /* 98 S> */ B(LdaSmi), U8(6),
+ /* 104 E> */ B(TestEqual), R(0),
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),
+ /* 110 S> */ B(Jump), U8(8),
+ /* 122 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ /* 144 S> */ B(LdaSmi), U8(10),
+ /* 144 E> */ B(TestLessThan), R(0),
+ B(JumpIfTrue), U8(-33),
/* 151 S> */ B(Ldar), R(1),
/* 161 S> */ B(Return),
]
@@ -332,28 +291,24 @@
} while (x);
return y;
"
-frame size: 3
+frame size: 2
parameter count: 1
-bytecode array length: 37
+bytecode array length: 29
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(10),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 54 S> */ B(LdaSmi), U8(1),
- /* 54 E> */ B(Star), R(1),
+ 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),
+ /* 64 S> */ B(LdaSmi), U8(12),
+ B(Mul), R(1),
+ B(Star), R(1),
+ /* 78 S> */ B(LdaSmi), U8(1),
+ B(Sub), R(0),
+ B(Star), R(0),
/* 98 S> */ B(Ldar), R(0),
- B(JumpIfToBooleanTrue), U8(-23),
+ B(JumpIfToBooleanTrue), U8(-15),
/* 102 S> */ B(Ldar), R(1),
/* 112 S> */ B(Return),
]
@@ -373,35 +328,28 @@
} while (false);
return y;
"
-frame size: 3
+frame size: 2
parameter count: 1
-bytecode array length: 54
+bytecode array length: 40
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 53 S> */ B(LdaSmi), U8(1),
- /* 53 E> */ B(Star), R(1),
+ 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),
+ /* 63 S> */ B(LdaSmi), U8(10),
+ B(Mul), R(1),
+ B(Star), R(1),
+ /* 77 S> */ B(LdaSmi), U8(5),
+ /* 83 E> */ B(TestEqual), R(0),
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),
+ /* 89 S> */ B(Jump), U8(16),
+ /* 98 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ /* 111 S> */ B(LdaSmi), U8(6),
+ /* 117 E> */ B(TestEqual), R(0),
B(JumpIfFalse), U8(4),
/* 123 S> */ B(Jump), U8(2),
/* 150 S> */ B(Ldar), R(1),
@@ -423,38 +371,31 @@
} while (true);
return y;
"
-frame size: 3
+frame size: 2
parameter count: 1
-bytecode array length: 56
+bytecode array length: 42
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 53 S> */ B(LdaSmi), U8(1),
- /* 53 E> */ B(Star), R(1),
+ 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),
+ /* 63 S> */ B(LdaSmi), U8(10),
+ B(Mul), R(1),
+ B(Star), R(1),
+ /* 77 S> */ B(LdaSmi), U8(5),
+ /* 83 E> */ B(TestEqual), R(0),
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),
+ /* 89 S> */ B(Jump), U8(18),
+ /* 98 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ /* 111 S> */ B(LdaSmi), U8(6),
+ /* 117 E> */ B(TestEqual), R(0),
B(JumpIfFalse), U8(4),
/* 123 S> */ B(Jump), U8(2),
- B(Jump), U8(-43),
+ B(Jump), U8(-29),
/* 149 S> */ B(Ldar), R(1),
/* 159 S> */ B(Return),
]
@@ -472,32 +413,26 @@
x = x + 1;
}
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 43
+bytecode array length: 31
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ 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),
+ /* 58 S> */ B(LdaSmi), U8(1),
+ /* 64 E> */ B(TestEqual), R(0),
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),
+ /* 70 S> */ B(Jump), U8(18),
+ /* 79 S> */ B(LdaSmi), U8(2),
+ /* 85 E> */ B(TestEqual), R(0),
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),
+ /* 91 S> */ B(Jump), U8(8),
+ /* 103 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ B(Jump), U8(-23),
B(LdaUndefined),
/* 116 S> */ B(Return),
]
@@ -514,32 +449,26 @@
x = x + 1;
}
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 43
+bytecode array length: 31
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 47 S> */ B(LdaZero),
- /* 47 E> */ B(Star), R(0),
+ 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),
+ /* 56 S> */ B(LdaSmi), U8(1),
+ /* 62 E> */ B(TestEqual), R(0),
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),
+ /* 68 S> */ B(Jump), U8(18),
+ /* 77 S> */ B(LdaSmi), U8(2),
+ /* 83 E> */ B(TestEqual), R(0),
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),
+ /* 89 S> */ B(Jump), U8(8),
+ /* 101 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ B(Jump), U8(-23),
B(LdaUndefined),
/* 114 S> */ B(Return),
]
@@ -556,32 +485,26 @@
if (x == 2) continue;
}
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 43
+bytecode array length: 31
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ 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),
+ /* 68 S> */ B(LdaSmi), U8(1),
+ /* 74 E> */ B(TestEqual), R(0),
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),
+ /* 80 S> */ B(Jump), U8(18),
+ /* 89 S> */ B(LdaSmi), U8(2),
+ /* 95 E> */ B(TestEqual), R(0),
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),
+ /* 55 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ B(Jump), U8(-23),
B(LdaUndefined),
/* 113 S> */ B(Return),
]
@@ -597,32 +520,26 @@
if (x == 2) continue;
}
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 43
+bytecode array length: 31
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 47 S> */ B(LdaZero),
- /* 47 E> */ B(Star), R(0),
+ 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),
+ /* 66 S> */ B(LdaSmi), U8(1),
+ /* 72 E> */ B(TestEqual), R(0),
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),
+ /* 78 S> */ B(Jump), U8(18),
+ /* 87 S> */ B(LdaSmi), U8(2),
+ /* 93 E> */ B(TestEqual), R(0),
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),
+ /* 53 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ B(Jump), U8(-23),
B(LdaUndefined),
/* 111 S> */ B(Return),
]
@@ -639,33 +556,27 @@
continue;
}
"
-frame size: 3
+frame size: 2
parameter count: 1
-bytecode array length: 44
+bytecode array length: 32
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ 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),
+ B(Star), R(1),
+ /* 63 S> */ B(LdaSmi), U8(100),
+ /* 63 E> */ B(TestLessThan), R(1),
+ B(JumpIfFalse), U8(19),
/* 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),
+ /* 85 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ 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),
+ /* 72 S> */ B(LdaSmi), U8(1),
+ B(Add), R(1),
+ B(Star), R(1),
+ B(Jump), U8(-21),
B(LdaUndefined),
/* 110 S> */ B(Return),
]
@@ -682,27 +593,25 @@
}
return y;
"
-frame size: 3
+frame size: 2
parameter count: 1
-bytecode array length: 34
+bytecode array length: 30
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 58 S> */ B(LdaSmi), U8(10),
- /* 58 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 62 S> */ B(Ldar), R(1),
- B(JumpIfToBooleanFalse), U8(20),
+ B(JumpIfToBooleanFalse), U8(16),
/* 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),
+ /* 74 S> */ B(LdaSmi), U8(12),
+ B(Mul), R(0),
+ B(Star), R(0),
/* 67 S> */ B(Ldar), R(1),
B(Dec),
- /* 67 E> */ B(Star), R(1),
- B(Jump), U8(-20),
+ B(Star), R(1),
+ B(Jump), U8(-16),
/* 88 S> */ B(Ldar), R(0),
/* 98 S> */ B(Return),
]
@@ -725,9 +634,9 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 58 S> */ B(LdaZero),
- /* 58 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 91 S> */ B(Ldar), R(0),
/* 101 S> */ B(Return),
]
@@ -745,30 +654,27 @@
};
return x;
"
-frame size: 3
+frame size: 2
parameter count: 1
-bytecode array length: 38
+bytecode array length: 32
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 58 S> */ B(LdaZero),
- /* 58 E> */ B(Star), R(1),
+ 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),
+ /* 76 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
+ /* 89 S> */ B(LdaSmi), U8(20),
+ /* 95 E> */ B(TestEqual), R(0),
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),
+ B(Star), R(1),
+ B(Jump), U8(-20),
/* 112 S> */ B(Ldar), R(0),
/* 122 S> */ B(Return),
]
@@ -791,18 +697,17 @@
"
frame size: 7
parameter count: 1
-bytecode array length: 120
+bytecode array length: 119
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 52 S> */ B(Ldar), R(1),
- B(JumpIfToBooleanFalse), U8(112),
+ B(JumpIfToBooleanFalse), U8(111),
/* 45 E> */ B(StackCheck),
B(LdaConstant), U8(0),
B(Star), R(4),
- B(Ldar), R(closure),
- B(Star), R(5),
+ B(Mov), R(closure), R(5),
B(CallRuntime), U16(Runtime::kPushBlockContext), R(4), U8(2),
B(PushContext), R(3),
B(LdaTheHole),
@@ -834,8 +739,8 @@
B(ToNumber),
B(Star), R(4),
B(Inc),
- /* 127 E> */ B(Star), R(5),
- B(LdaContextSlot), R(context), U8(4),
+ B(Star), R(5),
+ /* 127 E> */ B(LdaContextSlot), R(context), U8(4),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(3),
B(Star), R(6),
@@ -843,7 +748,7 @@
B(Ldar), R(5),
B(StaContextSlot), R(context), U8(4),
B(PopContext), R(3),
- B(Jump), U8(-112),
+ B(Jump), U8(-111),
B(LdaUndefined),
/* 137 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/BreakableBlocks.golden b/test/cctest/interpreter/bytecode_expectations/BreakableBlocks.golden
index 8573a1a..fab6901 100644
--- a/test/cctest/interpreter/bytecode_expectations/BreakableBlocks.golden
+++ b/test/cctest/interpreter/bytecode_expectations/BreakableBlocks.golden
@@ -17,17 +17,16 @@
}
return x;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 17
+bytecode array length: 15
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 56 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Star), R(0),
/* 69 S> */ B(Jump), U8(2),
/* 97 S> */ B(Ldar), R(0),
/* 107 S> */ B(Return),
@@ -52,34 +51,28 @@
"
frame size: 5
parameter count: 1
-bytecode array length: 72
+bytecode array length: 60
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 44 S> */ B(LdaZero),
- /* 44 E> */ B(Star), R(0),
+ 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),
+ B(Star), R(1),
+ /* 76 S> */ B(LdaSmi), U8(10),
+ /* 76 E> */ B(TestLessThan), R(1),
+ B(JumpIfFalse), U8(46),
/* 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),
+ B(Star), R(2),
+ /* 111 S> */ B(LdaSmi), U8(3),
+ /* 111 E> */ B(TestLessThan), R(2),
+ B(JumpIfFalse), U8(29),
/* 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(0),
+ /* 142 S> */ B(Ldar), R(2),
+ /* 150 E> */ B(Add), R(1),
B(Star), R(4),
B(LdaSmi), U8(12),
/* 152 E> */ B(TestEqual), R(4),
@@ -87,12 +80,12 @@
/* 161 S> */ B(Jump), U8(16),
/* 118 S> */ B(Ldar), R(2),
B(Inc),
- /* 118 E> */ B(Star), R(2),
- B(Jump), U8(-39),
+ B(Star), R(2),
+ B(Jump), U8(-31),
/* 84 S> */ B(Ldar), R(1),
B(Inc),
- /* 84 E> */ B(Star), R(1),
- B(Jump), U8(-60),
+ B(Star), R(1),
+ B(Jump), U8(-48),
/* 188 S> */ B(Ldar), R(0),
/* 200 S> */ B(Return),
]
@@ -111,13 +104,12 @@
"
frame size: 5
parameter count: 1
-bytecode array length: 51
+bytecode array length: 50
bytecodes: [
/* 30 E> */ B(StackCheck),
B(LdaConstant), U8(0),
B(Star), R(3),
- B(Ldar), R(closure),
- B(Star), R(4),
+ B(Mov), R(closure), R(4),
B(CallRuntime), U16(Runtime::kPushBlockContext), R(3), U8(2),
B(PushContext), R(2),
B(LdaTheHole),
@@ -160,7 +152,7 @@
"
frame size: 6
parameter count: 1
-bytecode array length: 131
+bytecode array length: 130
bytecodes: [
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
B(PushContext), R(2),
@@ -171,8 +163,7 @@
/* 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(Mov), R(closure), R(5),
B(CallRuntime), U16(Runtime::kPushBlockContext), R(4), U8(2),
B(PushContext), R(3),
B(LdaTheHole),
@@ -196,8 +187,8 @@
/* 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(Star), R(4),
+ /* 144 E> */ B(LdaContextSlot), R(context), U8(4),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(3),
B(Star), R(5),
@@ -206,8 +197,8 @@
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(Star), R(4),
+ /* 157 E> */ B(LdaContextSlot), R(context), U8(4),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(4),
B(Star), R(5),
diff --git a/test/cctest/interpreter/bytecode_expectations/CallGlobal.golden b/test/cctest/interpreter/bytecode_expectations/CallGlobal.golden
index 0d8624b..45fb07a 100644
--- a/test/cctest/interpreter/bytecode_expectations/CallGlobal.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CallGlobal.golden
@@ -16,18 +16,15 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 15
+bytecode array length: 12
bytecodes: [
/* 27 E> */ B(StackCheck),
- /* 32 S> */ B(LdaUndefined),
- B(Star), R(1),
- B(LdaGlobal), U8(0), U8(3),
- B(Star), R(0),
+ /* 32 S> */ B(LdrUndefined), R(1),
+ B(LdrGlobal), U8(3), R(0),
/* 39 E> */ B(Call), R(0), R(1), U8(1), U8(1),
/* 44 S> */ B(Return),
]
constant pool: [
- "t",
]
handlers: [
]
@@ -40,13 +37,11 @@
"
frame size: 5
parameter count: 1
-bytecode array length: 27
+bytecode array length: 24
bytecodes: [
/* 34 E> */ B(StackCheck),
- /* 39 S> */ B(LdaUndefined),
- B(Star), R(1),
- B(LdaGlobal), U8(0), U8(3),
- B(Star), R(0),
+ /* 39 S> */ B(LdrUndefined), R(1),
+ B(LdrGlobal), U8(3), R(0),
B(LdaSmi), U8(1),
B(Star), R(2),
B(LdaSmi), U8(2),
@@ -57,7 +52,6 @@
/* 58 S> */ B(Return),
]
constant pool: [
- "t",
]
handlers: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/CallLookupSlot.golden b/test/cctest/interpreter/bytecode_expectations/CallLookupSlot.golden
index 0ab5fcb..792faf3 100644
--- a/test/cctest/interpreter/bytecode_expectations/CallLookupSlot.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CallLookupSlot.golden
@@ -31,15 +31,15 @@
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(Mov), R(1), R(4),
+ B(Mov), R(3), R(5),
+ B(Mov), R(closure), R(6),
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),
diff --git a/test/cctest/interpreter/bytecode_expectations/CallNew.golden b/test/cctest/interpreter/bytecode_expectations/CallNew.golden
index 79dd5c1..2ee9613 100644
--- a/test/cctest/interpreter/bytecode_expectations/CallNew.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CallNew.golden
@@ -19,13 +19,12 @@
bytecode array length: 11
bytecodes: [
/* 45 E> */ B(StackCheck),
- /* 50 S> */ B(LdaGlobal), U8(0), U8(2),
- B(Star), R(0),
+ /* 50 S> */ B(LdrGlobal), U8(3), R(0),
+ B(Ldar), R(0),
/* 57 E> */ B(New), R(0), R(0), U8(0),
/* 68 S> */ B(Return),
]
constant pool: [
- InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
]
handlers: [
]
@@ -38,19 +37,17 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 17
+bytecode array length: 15
bytecodes: [
/* 58 E> */ B(StackCheck),
- /* 63 S> */ B(LdaGlobal), U8(0), U8(2),
- B(Star), R(0),
+ /* 63 S> */ B(LdrGlobal), U8(3), R(0),
B(LdaSmi), U8(3),
B(Star), R(1),
- /* 70 E> */ B(Ldar), R(0),
- B(New), R(0), R(1), U8(1),
+ B(Ldar), R(0),
+ /* 70 E> */ B(New), R(0), R(1), U8(1),
/* 82 S> */ B(Return),
]
constant pool: [
- InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
]
handlers: [
]
@@ -68,23 +65,21 @@
"
frame size: 4
parameter count: 1
-bytecode array length: 25
+bytecode array length: 23
bytecodes: [
/* 100 E> */ B(StackCheck),
- /* 105 S> */ B(LdaGlobal), U8(0), U8(2),
- B(Star), R(0),
+ /* 105 S> */ B(LdrGlobal), U8(3), 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),
+ B(Ldar), R(0),
+ /* 112 E> */ B(New), R(0), R(1), U8(3),
/* 130 S> */ B(Return),
]
constant pool: [
- InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
]
handlers: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/CallRuntime.golden b/test/cctest/interpreter/bytecode_expectations/CallRuntime.golden
index 69edecc..0a88098 100644
--- a/test/cctest/interpreter/bytecode_expectations/CallRuntime.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CallRuntime.golden
@@ -32,14 +32,12 @@
function f(a) { return %IsArray(a) }
f(undefined);
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 11
+bytecode array length: 7
bytecodes: [
/* 10 E> */ B(StackCheck),
- /* 16 S> */ B(Ldar), R(arg0),
- B(Star), R(0),
- B(CallRuntime), U16(Runtime::kIsArray), R(0), U8(1),
+ /* 16 S> */ B(CallRuntime), U16(Runtime::kIsArray), R(arg0), U8(1),
/* 35 S> */ B(Return),
]
constant pool: [
@@ -76,14 +74,13 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 15
+bytecode array length: 14
bytecodes: [
/* 10 E> */ B(StackCheck),
- /* 15 S> */ B(LdaUndefined),
- B(Star), R(0),
+ /* 15 S> */ B(LdrUndefined), R(0),
B(CreateArrayLiteral), U8(0), U8(0), U8(3),
B(Star), R(1),
- B(CallJSRuntime), U8(122), R(0), U8(2),
+ B(CallJSRuntime), U8(129), R(0), U8(2),
/* 44 S> */ B(Return),
]
constant pool: [
diff --git a/test/cctest/interpreter/bytecode_expectations/ClassAndSuperClass.golden b/test/cctest/interpreter/bytecode_expectations/ClassAndSuperClass.golden
index abe5b29..dc1e110 100644
--- a/test/cctest/interpreter/bytecode_expectations/ClassAndSuperClass.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ClassAndSuperClass.golden
@@ -24,22 +24,19 @@
"
frame size: 7
parameter count: 1
-bytecode array length: 57
+bytecode array length: 54
bytecodes: [
- B(Ldar), R(closure),
- B(Star), R(0),
+ B(Mov), R(closure), R(0),
/* 99 E> */ B(StackCheck),
- /* 104 S> */ B(Ldar), R(this),
- B(Star), R(3),
- /* 111 E> */ B(Ldar), R(0),
+ /* 104 S> */ B(Mov), R(this), R(3),
+ B(Ldar), R(closure),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(0),
B(Star), R(6),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(6), U8(1),
+ /* 111 E> */ 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(1),
+ /* 111 E> */ B(LdrKeyedProperty), R(6), U8(3), R(4),
B(LdaConstant), U8(2),
B(Star), R(5),
B(CallRuntime), U16(Runtime::kLoadFromSuper), R(3), U8(3),
@@ -76,38 +73,33 @@
"
frame size: 6
parameter count: 1
-bytecode array length: 80
+bytecode array length: 75
bytecodes: [
- B(Ldar), R(closure),
- B(Star), R(0),
+ B(Mov), R(closure), R(0),
/* 125 E> */ B(StackCheck),
- /* 130 S> */ B(Ldar), R(this),
- B(Star), R(1),
- /* 130 E> */ B(Ldar), R(0),
+ /* 130 S> */ B(Mov), R(this), R(1),
+ B(Ldar), R(closure),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(0),
B(Star), R(5),
- B(CallRuntime), U16(Runtime::kThrowReferenceError), R(5), U8(1),
+ /* 130 E> */ 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(1),
+ /* 130 E> */ B(LdrKeyedProperty), R(5), U8(1), 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(Star), R(4),
+ /* 138 E> */ B(CallRuntime), U16(Runtime::kStoreToSuper_Strict), R(1), U8(4),
+ /* 143 S> */ B(Mov), R(this), 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),
+ /* 150 E> */ 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(1),
+ /* 150 E> */ B(LdrKeyedProperty), R(4), U8(3), R(2),
B(LdaConstant), U8(2),
B(Star), R(3),
B(CallRuntime), U16(Runtime::kLoadFromSuper), R(1), U8(3),
@@ -136,14 +128,12 @@
"
frame size: 5
parameter count: 1
-bytecode array length: 106
+bytecode array length: 105
bytecodes: [
- B(Ldar), R(closure),
- B(Star), R(1),
- B(Ldar), R(new_target),
- B(Star), R(0),
+ B(Mov), R(closure), R(1),
+ B(Mov), R(new_target), R(0),
/* 113 E> */ B(StackCheck),
- /* 118 S> */ B(Ldar), R(1),
+ /* 118 S> */ B(Ldar), R(closure),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(0),
B(Star), R(3),
@@ -153,28 +143,28 @@
B(Star), R(2),
B(LdaSmi), U8(1),
B(Star), R(3),
- /* 118 E> */ B(Ldar), R(0),
+ 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(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(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),
+ /* 118 E> */ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(Mov), R(2), R(this),
+ /* 128 S> */ 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(Star), R(2),
B(LdaSmi), U8(2),
- /* 136 E> */ B(StoreICStrict), R(2), U8(3), U8(4),
+ /* 136 E> */ B(StaNamedPropertyStrict), R(2), U8(3), U8(4),
B(Ldar), R(this),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(2),
@@ -206,14 +196,12 @@
"
frame size: 4
parameter count: 1
-bytecode array length: 102
+bytecode array length: 101
bytecodes: [
- B(Ldar), R(closure),
- B(Star), R(1),
- B(Ldar), R(new_target),
- B(Star), R(0),
+ B(Mov), R(closure), R(1),
+ B(Mov), R(new_target), R(0),
/* 112 E> */ B(StackCheck),
- /* 117 S> */ B(Ldar), R(1),
+ /* 117 S> */ B(Ldar), R(closure),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(0),
B(Star), R(3),
@@ -221,28 +209,28 @@
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(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(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(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),
+ /* 117 E> */ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(3), U8(1),
+ B(Mov), R(2), R(this),
+ /* 126 S> */ 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(Star), R(2),
B(LdaSmi), U8(2),
- /* 134 E> */ B(StoreICStrict), R(2), U8(3), U8(4),
+ /* 134 E> */ B(StaNamedPropertyStrict), R(2), U8(3), U8(4),
B(Ldar), R(this),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(2),
diff --git a/test/cctest/interpreter/bytecode_expectations/ClassDeclarations.golden b/test/cctest/interpreter/bytecode_expectations/ClassDeclarations.golden
index 6947a27..c28e474 100644
--- a/test/cctest/interpreter/bytecode_expectations/ClassDeclarations.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ClassDeclarations.golden
@@ -16,7 +16,7 @@
"
frame size: 9
parameter count: 1
-bytecode array length: 73
+bytecode array length: 72
bytecodes: [
B(LdaTheHole),
B(Star), R(1),
@@ -33,9 +33,7 @@
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(LdrNamedProperty), R(2), U8(1), U8(1), R(3),
B(LdaConstant), U8(2),
B(Star), R(5),
B(CreateClosure), U8(3), U8(0),
@@ -44,10 +42,11 @@
B(Star), R(7),
B(LdaZero),
B(Star), R(8),
+ B(Mov), R(3), R(4),
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(Star), R(1),
B(LdaUndefined),
/* 149 S> */ B(Return),
]
@@ -69,7 +68,7 @@
"
frame size: 9
parameter count: 1
-bytecode array length: 73
+bytecode array length: 72
bytecodes: [
B(LdaTheHole),
B(Star), R(1),
@@ -86,9 +85,7 @@
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(LdrNamedProperty), R(2), U8(1), U8(1), R(3),
B(LdaConstant), U8(2),
B(Star), R(5),
B(CreateClosure), U8(3), U8(0),
@@ -97,10 +94,11 @@
B(Star), R(7),
B(LdaZero),
B(Star), R(8),
+ B(Mov), R(3), R(4),
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(Star), R(1),
B(LdaUndefined),
/* 149 S> */ B(Return),
]
@@ -124,7 +122,7 @@
"
frame size: 10
parameter count: 1
-bytecode array length: 127
+bytecode array length: 126
bytecodes: [
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
B(PushContext), R(2),
@@ -147,9 +145,7 @@
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(LdrNamedProperty), R(3), U8(3), U8(1), R(4),
/* 75 E> */ B(LdaContextSlot), R(context), U8(4),
B(ToName),
B(Star), R(6),
@@ -159,14 +155,15 @@
B(Star), R(8),
B(LdaSmi), U8(1),
B(Star), R(9),
+ B(Mov), R(4), R(5),
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(Mov), R(3), R(5),
+ B(JumpIfToBooleanFalse), U8(7),
B(CallRuntime), U16(Runtime::kThrowStaticPrototypeError), R(0), U8(0),
B(CreateClosure), U8(5), U8(0),
B(Star), R(7),
@@ -175,7 +172,7 @@
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(Star), R(1),
B(LdaUndefined),
/* 129 S> */ B(Return),
]
@@ -198,7 +195,7 @@
"
frame size: 7
parameter count: 1
-bytecode array length: 74
+bytecode array length: 73
bytecodes: [
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
B(PushContext), R(2),
@@ -219,11 +216,10 @@
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(LdrNamedProperty), R(3), U8(1), U8(1), R(4),
B(CallRuntime), U16(Runtime::kToFastProperties), R(3), U8(1),
B(Star), R(0),
- /* 49 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 87 S> */ B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(2),
B(Star), R(4),
diff --git a/test/cctest/interpreter/bytecode_expectations/CompoundExpressions.golden b/test/cctest/interpreter/bytecode_expectations/CompoundExpressions.golden
index 374a203..24c6a5e 100644
--- a/test/cctest/interpreter/bytecode_expectations/CompoundExpressions.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CompoundExpressions.golden
@@ -13,15 +13,15 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 15
+bytecode array length: 16
bytecodes: [
/* 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(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(2),
+ B(Add), R(0),
+ B(Mov), R(0), R(1),
+ B(Star), R(0),
B(LdaUndefined),
/* 53 S> */ B(Return),
]
@@ -36,15 +36,15 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 15
+bytecode array length: 16
bytecodes: [
/* 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(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(2),
+ B(Div), R(0),
+ B(Mov), R(0), R(1),
+ B(Star), R(0),
B(LdaUndefined),
/* 53 S> */ B(Return),
]
@@ -59,18 +59,16 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 27
+bytecode array length: 24
bytecodes: [
/* 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(Star), R(0),
+ /* 54 S> */ B(LdrNamedProperty), R(0), U8(1), U8(1), R(2),
B(LdaSmi), U8(2),
B(Mul), R(2),
- /* 61 E> */ B(StoreICSloppy), R(1), U8(1), U8(3),
+ /* 61 E> */ B(StaNamedPropertySloppy), R(0), U8(1), U8(3),
B(LdaUndefined),
/* 67 S> */ B(Return),
]
@@ -87,20 +85,18 @@
"
frame size: 4
parameter count: 1
-bytecode array length: 30
+bytecode array length: 27
bytecodes: [
/* 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(0),
+ /* 52 S> */ B(LdaSmi), U8(1),
B(Star), R(2),
- B(KeyedLoadIC), R(1), U8(1),
- B(Star), R(3),
+ B(LdrKeyedProperty), R(0), U8(1), R(3),
B(LdaSmi), U8(2),
B(BitwiseXor), R(3),
- /* 57 E> */ B(KeyedStoreICSloppy), R(1), R(2), U8(3),
+ /* 57 E> */ B(StaKeyedPropertySloppy), R(0), R(2), U8(3),
B(LdaUndefined),
/* 63 S> */ B(Return),
]
@@ -116,7 +112,7 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 30
+bytecode array length: 29
bytecodes: [
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
B(PushContext), R(0),
@@ -124,8 +120,7 @@
/* 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),
+ /* 75 S> */ B(LdrContextSlot), R(context), U8(4), R(1),
B(LdaSmi), U8(24),
B(BitwiseOr), R(1),
/* 77 E> */ B(StaContextSlot), R(context), U8(4),
diff --git a/test/cctest/interpreter/bytecode_expectations/ConstVariable.golden b/test/cctest/interpreter/bytecode_expectations/ConstVariable.golden
index 505d3e8..4c511b5 100644
--- a/test/cctest/interpreter/bytecode_expectations/ConstVariable.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ConstVariable.golden
@@ -19,7 +19,7 @@
B(Star), R(0),
/* 30 E> */ B(StackCheck),
/* 44 S> */ B(LdaSmi), U8(10),
- /* 44 E> */ B(Star), R(0),
+ B(Star), R(0),
B(LdaUndefined),
/* 48 S> */ B(Return),
]
@@ -40,7 +40,7 @@
B(Star), R(0),
/* 30 E> */ B(StackCheck),
/* 44 S> */ B(LdaSmi), U8(10),
- /* 44 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 48 S> */ B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(0),
B(Star), R(1),
@@ -59,22 +59,22 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 32
+bytecode array length: 33
bytecodes: [
B(LdaTheHole),
B(Star), R(0),
/* 30 E> */ B(StackCheck),
/* 48 S> */ B(LdaSmi), U8(20),
- /* 48 E> */ B(Star), R(1),
+ 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),
+ /* 48 E> */ 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),
+ B(Mov), R(1), R(0),
+ B(Ldar), R(0),
+ B(LdaUndefined),
/* 55 S> */ B(Return),
]
constant pool: [
@@ -89,23 +89,22 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 36
+bytecode array length: 35
bytecodes: [
B(LdaTheHole),
B(Star), R(0),
/* 30 E> */ B(StackCheck),
/* 44 S> */ B(LdaSmi), U8(10),
- /* 44 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 48 S> */ B(LdaSmi), U8(20),
- /* 50 E> */ B(Star), R(1),
+ 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),
+ /* 50 E> */ 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(Mov), R(1), R(0),
B(LdaUndefined),
/* 56 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/ConstVariableContextSlot.golden b/test/cctest/interpreter/bytecode_expectations/ConstVariableContextSlot.golden
index 6087101..1cfdea8 100644
--- a/test/cctest/interpreter/bytecode_expectations/ConstVariableContextSlot.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ConstVariableContextSlot.golden
@@ -80,8 +80,8 @@
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(Star), R(2),
+ /* 47 E> */ B(LdaContextSlot), R(context), U8(4),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(1),
B(Star), R(3),
@@ -118,8 +118,8 @@
/* 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(Star), R(2),
+ /* 50 E> */ B(LdaContextSlot), R(context), U8(4),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(1),
B(Star), R(3),
diff --git a/test/cctest/interpreter/bytecode_expectations/ContextParameters.golden b/test/cctest/interpreter/bytecode_expectations/ContextParameters.golden
index 72b731e..09a0f5a 100644
--- a/test/cctest/interpreter/bytecode_expectations/ContextParameters.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ContextParameters.golden
@@ -46,7 +46,7 @@
B(StaContextSlot), R(context), U8(4),
/* 10 E> */ B(StackCheck),
/* 27 S> */ B(CreateClosure), U8(0), U8(0),
- /* 27 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 53 S> */ B(LdaContextSlot), R(context), U8(4),
/* 66 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/ContextVariables.golden b/test/cctest/interpreter/bytecode_expectations/ContextVariables.golden
index ac5c042..7b69f9e 100644
--- a/test/cctest/interpreter/bytecode_expectations/ContextVariables.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ContextVariables.golden
@@ -79,13 +79,12 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 25
+bytecode array length: 24
bytecodes: [
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),
+ /* 41 S> */ B(LdrUndefined), R(2),
B(CreateClosure), U8(0), U8(0),
B(Star), R(1),
/* 64 E> */ B(Call), R(1), R(2), U8(1), U8(1),
@@ -106,7 +105,7 @@
"
frame size: 4
parameter count: 1
-bytecode array length: 47
+bytecode array length: 46
bytecodes: [
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
B(PushContext), R(0),
@@ -117,8 +116,7 @@
/* 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(Mov), R(closure), R(3),
B(CallRuntime), U16(Runtime::kPushBlockContext), R(2), U8(2),
B(PushContext), R(1),
B(LdaTheHole),
@@ -394,7 +392,7 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 1046
+bytecode array length: 1043
bytecodes: [
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
B(PushContext), R(0),
@@ -903,10 +901,8 @@
/* 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 S> */ B(LdrUndefined), R(2),
+ /* 3424 E> */ B(LdrGlobal), U8(1), 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),
@@ -914,7 +910,6 @@
/* 3454 S> */ B(Return),
]
constant pool: [
- InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
]
handlers: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/CountOperators.golden b/test/cctest/interpreter/bytecode_expectations/CountOperators.golden
index db9dcf3..3f6696c 100644
--- a/test/cctest/interpreter/bytecode_expectations/CountOperators.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CountOperators.golden
@@ -17,9 +17,9 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(Inc),
- /* 54 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 57 S> */ B(Return),
]
constant pool: [
@@ -37,11 +37,11 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(ToNumber),
B(Star), R(1),
B(Inc),
- /* 53 E> */ B(Star), R(0),
+ B(Star), R(0),
B(Ldar), R(1),
/* 57 S> */ B(Return),
]
@@ -60,9 +60,9 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(Dec),
- /* 54 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 57 S> */ B(Return),
]
constant pool: [
@@ -80,11 +80,11 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(ToNumber),
B(Star), R(1),
B(Dec),
- /* 53 E> */ B(Star), R(0),
+ B(Star), R(0),
B(Ldar), R(1),
/* 57 S> */ B(Return),
]
@@ -99,18 +99,17 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 26
+bytecode array length: 24
bytecodes: [
/* 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(0),
+ /* 54 S> */ B(LdaNamedProperty), R(0), U8(1), U8(1),
B(ToNumber),
B(Star), R(2),
B(Inc),
- /* 66 E> */ B(StoreICSloppy), R(1), U8(1), U8(3),
+ /* 66 E> */ B(StaNamedPropertySloppy), R(0), U8(1), U8(3),
B(Ldar), R(2),
/* 70 S> */ B(Return),
]
@@ -127,16 +126,15 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 21
+bytecode array length: 19
bytecodes: [
/* 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(0),
+ /* 54 S> */ B(LdaNamedProperty), R(0), U8(1), U8(1),
B(Dec),
- /* 65 E> */ B(StoreICSloppy), R(1), U8(1), U8(3),
+ /* 65 E> */ B(StaNamedPropertySloppy), R(0), U8(1), U8(3),
/* 70 S> */ B(Return),
]
constant pool: [
@@ -152,22 +150,20 @@
"
frame size: 5
parameter count: 1
-bytecode array length: 33
+bytecode array length: 29
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 45 S> */ B(LdaConstant), U8(0),
- /* 45 E> */ B(Star), R(0),
+ 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(Star), R(1),
+ /* 72 S> */ B(Ldar), R(0),
+ /* 81 E> */ B(LdaKeyedProperty), R(1), U8(1),
B(ToNumber),
B(Star), R(4),
B(Dec),
- /* 86 E> */ B(KeyedStoreICSloppy), R(2), R(3), U8(3),
+ /* 86 E> */ B(StaKeyedPropertySloppy), R(1), R(0), U8(3),
B(Ldar), R(4),
/* 90 S> */ B(Return),
]
@@ -182,22 +178,20 @@
snippet: "
var name = 'var'; var a = { val: 1 }; return ++a[name];
"
-frame size: 4
+frame size: 3
parameter count: 1
-bytecode array length: 28
+bytecode array length: 24
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 45 S> */ B(LdaConstant), U8(0),
- /* 45 E> */ B(Star), R(0),
+ 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(Star), R(1),
+ /* 72 S> */ B(Ldar), R(0),
+ /* 83 E> */ B(LdaKeyedProperty), R(1), U8(1),
B(Inc),
- /* 87 E> */ B(KeyedStoreICSloppy), R(2), R(3), U8(3),
+ /* 87 E> */ B(StaKeyedPropertySloppy), R(1), R(0), U8(3),
/* 90 S> */ B(Return),
]
constant pool: [
@@ -221,7 +215,7 @@
/* 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),
+ B(Star), R(0),
/* 78 S> */ B(LdaContextSlot), R(context), U8(4),
B(Inc),
/* 87 E> */ B(StaContextSlot), R(context), U8(4),
@@ -247,7 +241,7 @@
/* 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),
+ B(Star), R(0),
/* 78 S> */ B(LdaContextSlot), R(context), U8(4),
B(ToNumber),
B(Star), R(2),
@@ -268,21 +262,20 @@
"
frame size: 4
parameter count: 1
-bytecode array length: 28
+bytecode array length: 26
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 44 S> */ B(LdaSmi), U8(1),
- /* 44 E> */ B(Star), R(0),
+ 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(Star), R(1),
+ /* 63 S> */ B(Ldar), R(0),
B(ToNumber),
B(Star), R(3),
B(Inc),
- /* 75 E> */ B(Star), R(0),
+ B(Star), R(0),
B(LdaSmi), U8(2),
- /* 79 E> */ B(KeyedStoreICSloppy), R(2), R(3), U8(1),
+ /* 79 E> */ B(StaKeyedPropertySloppy), R(1), R(3), U8(1),
/* 84 S> */ B(Return),
]
constant pool: [
diff --git a/test/cctest/interpreter/bytecode_expectations/CreateArguments.golden b/test/cctest/interpreter/bytecode_expectations/CreateArguments.golden
index 6788a7c..edd6f05 100644
--- a/test/cctest/interpreter/bytecode_expectations/CreateArguments.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CreateArguments.golden
@@ -15,12 +15,12 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 7
+bytecode array length: 6
bytecodes: [
B(CreateMappedArguments),
B(Star), R(0),
/* 10 E> */ B(StackCheck),
- /* 15 S> */ B(Ldar), R(0),
+ /* 15 S> */ B(Nop),
/* 33 S> */ B(Return),
]
constant pool: [
@@ -33,17 +33,15 @@
function f() { return arguments[0]; }
f();
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 13
+bytecode array length: 9
bytecodes: [
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),
+ /* 15 S> */ B(LdaZero),
+ /* 31 E> */ B(LdaKeyedProperty), R(0), U8(1),
/* 36 S> */ B(Return),
]
constant pool: [
@@ -58,12 +56,12 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 7
+bytecode array length: 6
bytecodes: [
B(CreateUnmappedArguments),
B(Star), R(0),
/* 10 E> */ B(StackCheck),
- /* 29 S> */ B(Ldar), R(0),
+ /* 29 S> */ B(Nop),
/* 47 S> */ B(Return),
]
constant pool: [
@@ -76,9 +74,9 @@
function f(a) { return arguments[0]; }
f();
"
-frame size: 3
+frame size: 2
parameter count: 2
-bytecode array length: 25
+bytecode array length: 21
bytecodes: [
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
B(PushContext), R(1),
@@ -87,10 +85,8 @@
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),
+ /* 16 S> */ B(LdaZero),
+ /* 32 E> */ B(LdaKeyedProperty), R(0), U8(1),
/* 37 S> */ B(Return),
]
constant pool: [
@@ -105,7 +101,7 @@
"
frame size: 2
parameter count: 4
-bytecode array length: 29
+bytecode array length: 28
bytecodes: [
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
B(PushContext), R(1),
@@ -118,7 +114,7 @@
B(CreateMappedArguments),
B(Star), R(0),
/* 10 E> */ B(StackCheck),
- /* 22 S> */ B(Ldar), R(0),
+ /* 22 S> */ B(Nop),
/* 40 S> */ B(Return),
]
constant pool: [
@@ -133,12 +129,12 @@
"
frame size: 1
parameter count: 4
-bytecode array length: 7
+bytecode array length: 6
bytecodes: [
B(CreateUnmappedArguments),
B(Star), R(0),
/* 10 E> */ B(StackCheck),
- /* 36 S> */ B(Ldar), R(0),
+ /* 36 S> */ B(Nop),
/* 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 341ad9c..feb9088 100644
--- a/test/cctest/interpreter/bytecode_expectations/CreateRestParameter.golden
+++ b/test/cctest/interpreter/bytecode_expectations/CreateRestParameter.golden
@@ -15,12 +15,12 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 7
+bytecode array length: 6
bytecodes: [
B(CreateRestParameter),
B(Star), R(0),
/* 10 E> */ B(StackCheck),
- /* 26 S> */ B(Ldar), R(0),
+ /* 26 S> */ B(Nop),
/* 43 S> */ B(Return),
]
constant pool: [
@@ -35,15 +35,14 @@
"
frame size: 2
parameter count: 2
-bytecode array length: 14
+bytecode array length: 13
bytecodes: [
B(CreateRestParameter),
B(Star), R(0),
B(LdaTheHole),
B(Star), R(1),
/* 10 E> */ B(StackCheck),
- B(Ldar), R(arg0),
- B(Star), R(1),
+ B(Mov), R(arg0), R(1),
/* 29 S> */ B(Ldar), R(0),
/* 46 S> */ B(Return),
]
@@ -57,21 +56,18 @@
function f(a, ...restArgs) { return restArgs[0]; }
f();
"
-frame size: 3
+frame size: 2
parameter count: 2
-bytecode array length: 20
+bytecode array length: 15
bytecodes: [
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),
+ B(Mov), R(arg0), R(1),
+ /* 29 S> */ B(LdaZero),
+ /* 44 E> */ B(LdaKeyedProperty), R(0), U8(1),
/* 49 S> */ B(Return),
]
constant pool: [
@@ -86,7 +82,7 @@
"
frame size: 5
parameter count: 2
-bytecode array length: 35
+bytecode array length: 25
bytecodes: [
B(CreateUnmappedArguments),
B(Star), R(0),
@@ -95,17 +91,11 @@
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(Mov), R(arg0), R(2),
+ /* 29 S> */ B(LdaZero),
+ /* 44 E> */ B(LdrKeyedProperty), R(1), U8(1), R(4),
+ B(LdaZero),
+ /* 59 E> */ B(LdaKeyedProperty), R(0), U8(3),
B(Add), R(4),
/* 64 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/DeadCodeRemoval.golden b/test/cctest/interpreter/bytecode_expectations/DeadCodeRemoval.golden
index 29f101a..2530404 100644
--- a/test/cctest/interpreter/bytecode_expectations/DeadCodeRemoval.golden
+++ b/test/cctest/interpreter/bytecode_expectations/DeadCodeRemoval.golden
@@ -34,7 +34,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 66 S> */ B(LdaSmi), U8(1),
- /* 66 E> */ B(Star), R(0),
+ B(Star), R(0),
B(LdaUndefined),
/* 69 S> */ B(Return),
]
@@ -70,7 +70,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(JumpIfToBooleanFalse), U8(5),
/* 54 S> */ B(LdaSmi), U8(1),
/* 77 S> */ B(Return),
diff --git a/test/cctest/interpreter/bytecode_expectations/DeclareGlobals.golden b/test/cctest/interpreter/bytecode_expectations/DeclareGlobals.golden
index a1505f0..97e403e 100644
--- a/test/cctest/interpreter/bytecode_expectations/DeclareGlobals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/DeclareGlobals.golden
@@ -103,7 +103,7 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 29
+bytecode array length: 26
bytecodes: [
B(LdaConstant), U8(0),
B(Star), R(1),
@@ -111,17 +111,14 @@
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 S> */ B(LdrUndefined), R(2),
+ B(LdrGlobal), U8(1), 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,
- InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
]
handlers: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/Delete.golden b/test/cctest/interpreter/bytecode_expectations/Delete.golden
index 2a355ab..b4ed9f6 100644
--- a/test/cctest/interpreter/bytecode_expectations/Delete.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Delete.golden
@@ -13,15 +13,14 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 16
+bytecode array length: 14
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 56 S> */ B(LdaConstant), U8(1),
+ B(DeletePropertySloppy), R(0),
/* 75 S> */ B(Return),
]
constant pool: [
@@ -37,15 +36,14 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 16
+bytecode array length: 14
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 70 S> */ B(LdaConstant), U8(1),
+ B(DeletePropertyStrict), R(0),
/* 89 S> */ B(Return),
]
constant pool: [
@@ -61,15 +59,14 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 16
+bytecode array length: 14
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 56 S> */ B(LdaSmi), U8(2),
+ B(DeletePropertySloppy), R(0),
/* 76 S> */ B(Return),
]
constant pool: [
@@ -88,7 +85,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(10),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 46 S> */ B(LdaFalse),
/* 63 S> */ B(Return),
]
@@ -106,7 +103,7 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 30
+bytecode array length: 29
bytecodes: [
B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
B(PushContext), R(0),
@@ -115,8 +112,7 @@
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),
+ /* 93 S> */ B(LdrContextSlot), R(context), U8(4), R(1),
B(LdaSmi), U8(1),
B(DeletePropertyStrict), R(1),
/* 113 S> */ B(Return),
diff --git a/test/cctest/interpreter/bytecode_expectations/DoExpression.golden b/test/cctest/interpreter/bytecode_expectations/DoExpression.golden
index 68f264f..0fae9e6 100644
--- a/test/cctest/interpreter/bytecode_expectations/DoExpression.golden
+++ b/test/cctest/interpreter/bytecode_expectations/DoExpression.golden
@@ -14,11 +14,11 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 6
+bytecode array length: 7
bytecodes: [
/* 30 E> */ B(StackCheck),
- /* 42 S> */ B(Ldar), R(0),
- /* 42 E> */ B(Star), R(1),
+ /* 42 S> */ B(Mov), R(0), R(1),
+ /* 50 S> */ B(Ldar), R(1),
/* 60 S> */ B(Return),
]
constant pool: [
@@ -32,14 +32,15 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 11
+bytecode array length: 13
bytecodes: [
/* 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),
+ B(Star), R(1),
+ /* 42 S> */ B(LdrUndefined), R(0),
+ B(Ldar), R(0),
+ B(Star), R(2),
+ /* 63 S> */ B(Nop),
/* 73 S> */ B(Return),
]
constant pool: [
@@ -53,21 +54,17 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 25
+bytecode array length: 17
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 34 E> */ B(StackCheck),
/* 56 S> */ B(LdaSmi), U8(10),
- /* 56 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 69 S> */ B(Inc),
- /* 71 E> */ B(Star), R(1),
+ 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),
+ /* 74 S> */ B(Jump), U8(4),
+ B(Jump), U8(-12),
B(LdaUndefined),
/* 94 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/Eval.golden b/test/cctest/interpreter/bytecode_expectations/Eval.golden
index 7c3915c..6dfdf95 100644
--- a/test/cctest/interpreter/bytecode_expectations/Eval.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Eval.golden
@@ -29,15 +29,15 @@
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(Mov), R(1), R(4),
+ B(Mov), R(3), R(5),
+ B(Mov), R(closure), R(6),
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),
diff --git a/test/cctest/interpreter/bytecode_expectations/ForIn.golden b/test/cctest/interpreter/bytecode_expectations/ForIn.golden
index 2b61b64..8bc9d2a 100644
--- a/test/cctest/interpreter/bytecode_expectations/ForIn.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ForIn.golden
@@ -65,30 +65,30 @@
"
frame size: 8
parameter count: 1
-bytecode array length: 45
+bytecode array length: 44
bytecodes: [
/* 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(Star), R(1),
+ /* 68 S> */ B(JumpIfUndefined), U8(37),
+ B(JumpIfNull), U8(35),
B(ToObject),
- B(Star), R(3),
B(ForInPrepare), R(4),
+ B(Star), R(3),
B(LdaZero),
B(Star), R(7),
/* 63 S> */ B(ForInDone), R(7), R(6),
- B(JumpIfTrue), U8(23),
+ B(JumpIfTrue), U8(22),
B(ForInNext), R(3), R(7), R(4), U8(1),
- B(JumpIfUndefined), U8(10),
+ B(JumpIfUndefined), U8(9),
B(Star), R(0),
/* 54 E> */ B(StackCheck),
- B(Ldar), R(0),
B(Star), R(2),
+ /* 73 S> */ B(Nop),
/* 85 S> */ B(Return),
B(ForInStep), R(7),
B(Star), R(7),
- B(Jump), U8(-24),
+ B(Jump), U8(-23),
B(LdaUndefined),
/* 85 S> */ B(Return),
]
@@ -105,35 +105,33 @@
"
frame size: 9
parameter count: 1
-bytecode array length: 57
+bytecode array length: 54
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 59 S> */ B(CreateArrayLiteral), U8(0), U8(0), U8(3),
- B(JumpIfUndefined), U8(47),
- B(JumpIfNull), U8(45),
+ B(JumpIfUndefined), U8(44),
+ B(JumpIfNull), U8(42),
B(ToObject),
- B(Star), R(3),
B(ForInPrepare), R(4),
+ B(Star), R(3),
B(LdaZero),
B(Star), R(7),
/* 54 S> */ B(ForInDone), R(7), R(6),
- B(JumpIfTrue), U8(32),
+ B(JumpIfTrue), U8(29),
B(ForInNext), R(3), R(7), R(4), U8(1),
- B(JumpIfUndefined), U8(19),
+ B(JumpIfUndefined), U8(16),
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),
+ /* 70 S> */ B(Ldar), R(0),
+ /* 75 E> */ B(Add), R(1),
+ B(Mov), R(1), R(8),
+ B(Star), R(1),
+ /* 72 E> */ B(ForInStep), R(7),
B(Star), R(7),
- B(Jump), U8(-33),
+ B(Jump), U8(-30),
B(LdaUndefined),
/* 80 S> */ B(Return),
]
@@ -153,49 +151,42 @@
"
frame size: 8
parameter count: 1
-bytecode array length: 94
+bytecode array length: 80
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(CreateObjectLiteral), U8(0), U8(0), U8(1),
B(Star), R(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 77 S> */ B(CreateArrayLiteral), U8(1), U8(1), U8(3),
- B(JumpIfUndefined), U8(79),
- B(JumpIfNull), U8(77),
+ B(JumpIfUndefined), U8(65),
+ B(JumpIfNull), U8(63),
B(ToObject),
- B(Star), R(1),
B(ForInPrepare), R(2),
+ B(Star), R(1),
B(LdaZero),
B(Star), R(5),
/* 68 S> */ B(ForInDone), R(5), R(4),
- B(JumpIfTrue), U8(64),
+ B(JumpIfTrue), U8(50),
B(ForInNext), R(1), R(5), R(2), U8(9),
- B(JumpIfUndefined), U8(51),
+ B(JumpIfUndefined), U8(37),
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),
+ /* 67 E> */ B(StaNamedPropertySloppy), R(0), 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),
+ /* 95 S> */ B(Nop),
+ /* 100 E> */ B(LdrNamedProperty), R(0), U8(2), U8(3), 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),
+ /* 113 S> */ B(Jump), U8(16),
+ /* 125 S> */ B(Nop),
+ /* 130 E> */ B(LdrNamedProperty), R(0), U8(2), U8(5), 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(Jump), U8(-51),
B(LdaUndefined),
/* 152 S> */ B(Return),
]
@@ -214,39 +205,35 @@
"
frame size: 9
parameter count: 1
-bytecode array length: 69
+bytecode array length: 61
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(CreateArrayLiteral), U8(0), U8(0), U8(3),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 72 S> */ B(CreateArrayLiteral), U8(1), U8(1), U8(3),
- B(JumpIfUndefined), U8(56),
- B(JumpIfNull), U8(54),
+ B(JumpIfUndefined), U8(48),
+ B(JumpIfNull), U8(46),
B(ToObject),
- B(Star), R(1),
B(ForInPrepare), R(2),
+ B(Star), R(1),
B(LdaZero),
B(Star), R(5),
/* 65 S> */ B(ForInDone), R(5), R(4),
- B(JumpIfTrue), U8(41),
+ B(JumpIfTrue), U8(33),
B(ForInNext), R(1), R(5), R(2), U8(7),
- B(JumpIfUndefined), U8(28),
+ B(JumpIfUndefined), U8(20),
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),
+ /* 64 E> */ B(StaKeyedPropertySloppy), R(0), 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),
+ /* 83 S> */ B(LdaSmi), U8(3),
+ /* 91 E> */ B(LdaKeyedProperty), R(0), U8(3),
/* 98 S> */ B(Return),
B(ForInStep), R(5),
B(Star), R(5),
- B(Jump), U8(-42),
+ B(Jump), U8(-34),
B(LdaUndefined),
/* 98 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/ForOf.golden b/test/cctest/interpreter/bytecode_expectations/ForOf.golden
index 6fb1c4b..06cdb3d 100644
--- a/test/cctest/interpreter/bytecode_expectations/ForOf.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ForOf.golden
@@ -13,70 +13,52 @@
"
frame size: 16
parameter count: 1
-bytecode array length: 347
+bytecode array length: 284
bytecodes: [
/* 30 E> */ B(StackCheck),
- B(LdaUndefined),
- B(Star), R(4),
+ B(LdrUndefined), 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),
+ B(LdaConstant), U8(1),
+ /* 48 E> */ B(LdrKeyedProperty), R(14), U8(3), 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(Star), R(1),
+ /* 45 S> */ B(LdrNamedProperty), R(1), U8(2), U8(7), R(14),
+ /* 45 E> */ B(Call), R(14), R(1), U8(1), U8(5),
+ B(Star), R(2),
+ /* 45 E> */ B(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(2), 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(JumpIfFalse), U8(7),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(2), U8(1),
+ B(LdaNamedProperty), R(2), U8(3), U8(9),
+ B(JumpIfToBooleanTrue), U8(22),
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(LdrNamedProperty), R(2), U8(4), U8(11), R(0),
B(Ldar), R(0),
- B(Star), R(7),
+ /* 34 E> */ B(StackCheck),
+ B(Mov), R(0), R(7),
B(LdaZero),
B(Star), R(3),
- B(Jump), U8(-70),
- B(Jump), U8(47),
+ B(Jump), U8(-48),
+ B(Jump), U8(41),
B(Star), R(14),
B(LdaConstant), U8(5),
B(Star), R(13),
- B(Ldar), R(closure),
- B(Star), R(15),
+ B(Mov), R(closure), 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(TestEqualStrict), R(3),
B(JumpIfFalse), U8(6),
B(LdaSmi), U8(1),
B(Star), R(3),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(13),
+ B(LdrContextSlot), R(context), U8(4), R(13),
B(CallRuntime), U16(Runtime::kReThrow), R(13), U8(1),
B(PopContext), R(8),
B(LdaSmi), U8(-1),
@@ -87,31 +69,21 @@
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(TestEqualStrict), R(3),
+ B(JumpIfTrue), U8(5),
B(LdaUndefined),
- B(TestEqualStrict), R(12),
+ B(TestEqualStrict), R(1),
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(JumpIfFalse), U8(118),
+ B(LdrNamedProperty), R(1), U8(6), U8(13), R(5),
B(LdaNull),
- B(TestEqual), R(12),
+ B(TestEqual), R(5),
B(JumpIfFalse), U8(4),
- B(Jump), U8(124),
- B(Ldar), R(3),
- B(Star), R(12),
+ B(Jump), U8(106),
B(LdaSmi), U8(1),
- B(TestEqualStrict), R(12),
- B(JumpIfFalse), U8(79),
+ B(TestEqualStrict), R(3),
+ B(JumpIfFalse), U8(75),
B(Ldar), R(5),
B(TypeOf),
B(Star), R(12),
@@ -119,44 +91,36 @@
B(TestEqualStrict), R(12),
B(JumpIfFalse), U8(4),
B(Jump), U8(18),
- B(Wide), B(LdaSmi), U16(129),
+ B(Wide), B(LdaSmi), U16(128),
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(Mov), R(5), R(13),
+ B(Mov), R(1), R(14),
+ B(InvokeIntrinsic), U8(Runtime::k_Call), R(13), U8(2),
+ B(Jump), U8(29),
B(Star), R(14),
B(LdaConstant), U8(5),
B(Star), R(13),
- B(Ldar), R(closure),
- B(Star), R(15),
+ B(Mov), R(closure), 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(Jump), U8(27),
+ B(Mov), R(5), R(12),
+ B(Mov), R(1), R(13),
+ B(InvokeIntrinsic), U8(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(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(6), 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(Jump), U8(7),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(6), U8(1),
B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(11), U8(1),
B(LdaZero),
B(TestEqualStrict), R(9),
@@ -177,12 +141,11 @@
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
- kInstanceTypeDontCare,
]
handlers: [
- [10, 152, 158],
- [13, 105, 107],
- [250, 263, 265],
+ [9, 122, 128],
+ [12, 81, 83],
+ [201, 211, 213],
]
---
@@ -192,74 +155,54 @@
"
frame size: 17
parameter count: 1
-bytecode array length: 363
+bytecode array length: 297
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
- /* 42 E> */ B(Star), R(7),
- B(LdaUndefined),
- B(Star), R(4),
+ B(Star), R(7),
+ B(LdrUndefined), 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),
+ /* 68 S> */ B(LdaConstant), U8(1),
+ /* 68 E> */ B(LdrKeyedProperty), R(7), U8(3), R(14),
+ /* 68 E> */ B(Call), R(14), R(7), U8(1), U8(1),
+ B(Star), R(1),
+ /* 65 S> */ B(LdrNamedProperty), R(1), U8(2), U8(7), R(15),
+ /* 65 E> */ B(Call), R(15), R(1), U8(1), U8(5),
+ B(Star), R(2),
+ /* 65 E> */ B(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(2), 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(JumpIfFalse), U8(7),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(2), U8(1),
+ B(LdaNamedProperty), R(2), U8(3), U8(9),
+ B(JumpIfToBooleanTrue), U8(27),
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(LdrNamedProperty), R(2), U8(4), U8(11), R(0),
B(Ldar), R(0),
- B(Star), R(8),
- /* 73 S> */ B(Star), R(11),
- B(LdaZero),
+ /* 54 E> */ B(StackCheck),
+ B(Mov), R(0), R(8),
+ /* 73 S> */ B(LdaZero),
B(Star), R(10),
- B(Jump), U8(63),
- B(Jump), U8(-74),
- B(Jump), U8(47),
+ B(Mov), R(0), R(11),
+ B(Jump), U8(57),
+ B(Jump), U8(-53),
+ B(Jump), U8(41),
B(Star), R(15),
B(LdaConstant), U8(5),
B(Star), R(14),
- B(Ldar), R(closure),
- B(Star), R(16),
+ B(Mov), R(closure), 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(TestEqualStrict), R(3),
B(JumpIfFalse), U8(6),
B(LdaSmi), U8(1),
B(Star), R(3),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(14),
+ B(LdrContextSlot), R(context), U8(4), R(14),
B(CallRuntime), U16(Runtime::kReThrow), R(14), U8(1),
B(PopContext), R(9),
B(LdaSmi), U8(-1),
@@ -270,31 +213,21 @@
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(TestEqualStrict), R(3),
+ B(JumpIfTrue), U8(5),
B(LdaUndefined),
- B(TestEqualStrict), R(13),
+ B(TestEqualStrict), R(1),
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(JumpIfFalse), U8(118),
+ B(LdrNamedProperty), R(1), U8(6), U8(13), R(5),
B(LdaNull),
- B(TestEqual), R(13),
+ B(TestEqual), R(5),
B(JumpIfFalse), U8(4),
- B(Jump), U8(124),
- B(Ldar), R(3),
- B(Star), R(13),
+ B(Jump), U8(106),
B(LdaSmi), U8(1),
- B(TestEqualStrict), R(13),
- B(JumpIfFalse), U8(79),
+ B(TestEqualStrict), R(3),
+ B(JumpIfFalse), U8(75),
B(Ldar), R(5),
B(TypeOf),
B(Star), R(13),
@@ -302,44 +235,36 @@
B(TestEqualStrict), R(13),
B(JumpIfFalse), U8(4),
B(Jump), U8(18),
- B(Wide), B(LdaSmi), U16(129),
+ B(Wide), B(LdaSmi), U16(128),
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(Mov), R(5), R(14),
+ B(Mov), R(1), R(15),
+ B(InvokeIntrinsic), U8(Runtime::k_Call), R(14), U8(2),
+ B(Jump), U8(29),
B(Star), R(15),
B(LdaConstant), U8(5),
B(Star), R(14),
- B(Ldar), R(closure),
- B(Star), R(16),
+ B(Mov), R(closure), 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(Jump), U8(27),
+ B(Mov), R(5), R(13),
+ B(Mov), R(1), R(14),
+ B(InvokeIntrinsic), U8(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(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(6), 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(Jump), U8(7),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(6), U8(1),
B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(12), U8(1),
B(LdaZero),
B(TestEqualStrict), R(10),
@@ -365,12 +290,11 @@
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
- kInstanceTypeDontCare,
]
handlers: [
- [14, 158, 164],
- [17, 111, 113],
- [257, 270, 272],
+ [13, 125, 131],
+ [16, 84, 86],
+ [205, 215, 217],
]
---
@@ -382,81 +306,60 @@
"
frame size: 16
parameter count: 1
-bytecode array length: 369
+bytecode array length: 300
bytecodes: [
/* 30 E> */ B(StackCheck),
- B(LdaUndefined),
- B(Star), R(4),
+ B(LdrUndefined), 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),
+ B(LdaConstant), U8(1),
+ /* 48 E> */ B(LdrKeyedProperty), R(14), U8(3), 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(Star), R(1),
+ /* 45 S> */ B(LdrNamedProperty), R(1), U8(2), U8(7), R(14),
+ /* 45 E> */ B(Call), R(14), R(1), U8(1), U8(5),
+ B(Star), R(2),
+ /* 45 E> */ B(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(2), 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(JumpIfFalse), U8(7),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(2), U8(1),
+ B(LdaNamedProperty), R(2), U8(3), U8(9),
+ B(JumpIfToBooleanTrue), U8(38),
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(LdrNamedProperty), R(2), U8(4), U8(11), R(0),
B(Ldar), R(0),
- B(Star), R(7),
- /* 66 S> */ B(Star), R(13),
- B(LdaSmi), U8(10),
- /* 72 E> */ B(TestEqual), R(13),
+ /* 34 E> */ B(StackCheck),
+ B(Mov), R(0), R(7),
+ /* 66 S> */ B(LdaSmi), U8(10),
+ /* 72 E> */ B(TestEqual), R(7),
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),
+ /* 79 S> */ B(Jump), U8(13),
+ /* 91 S> */ B(LdaSmi), U8(20),
+ /* 97 E> */ B(TestEqual), R(7),
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(Jump), U8(-64),
+ B(Jump), U8(41),
B(Star), R(14),
B(LdaConstant), U8(5),
B(Star), R(13),
- B(Ldar), R(closure),
- B(Star), R(15),
+ B(Mov), R(closure), 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(TestEqualStrict), R(3),
B(JumpIfFalse), U8(6),
B(LdaSmi), U8(1),
B(Star), R(3),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(13),
+ B(LdrContextSlot), R(context), U8(4), R(13),
B(CallRuntime), U16(Runtime::kReThrow), R(13), U8(1),
B(PopContext), R(8),
B(LdaSmi), U8(-1),
@@ -467,31 +370,21 @@
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(TestEqualStrict), R(3),
+ B(JumpIfTrue), U8(5),
B(LdaUndefined),
- B(TestEqualStrict), R(12),
+ B(TestEqualStrict), R(1),
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(JumpIfFalse), U8(118),
+ B(LdrNamedProperty), R(1), U8(6), U8(13), R(5),
B(LdaNull),
- B(TestEqual), R(12),
+ B(TestEqual), R(5),
B(JumpIfFalse), U8(4),
- B(Jump), U8(124),
- B(Ldar), R(3),
- B(Star), R(12),
+ B(Jump), U8(106),
B(LdaSmi), U8(1),
- B(TestEqualStrict), R(12),
- B(JumpIfFalse), U8(79),
+ B(TestEqualStrict), R(3),
+ B(JumpIfFalse), U8(75),
B(Ldar), R(5),
B(TypeOf),
B(Star), R(12),
@@ -499,44 +392,36 @@
B(TestEqualStrict), R(12),
B(JumpIfFalse), U8(4),
B(Jump), U8(18),
- B(Wide), B(LdaSmi), U16(129),
+ B(Wide), B(LdaSmi), U16(128),
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(Mov), R(5), R(13),
+ B(Mov), R(1), R(14),
+ B(InvokeIntrinsic), U8(Runtime::k_Call), R(13), U8(2),
+ B(Jump), U8(29),
B(Star), R(14),
B(LdaConstant), U8(5),
B(Star), R(13),
- B(Ldar), R(closure),
- B(Star), R(15),
+ B(Mov), R(closure), 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(Jump), U8(27),
+ B(Mov), R(5), R(12),
+ B(Mov), R(1), R(13),
+ B(InvokeIntrinsic), U8(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(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(6), 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(Jump), U8(7),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(6), U8(1),
B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(11), U8(1),
B(LdaZero),
B(TestEqualStrict), R(9),
@@ -557,12 +442,11 @@
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
- kInstanceTypeDontCare,
]
handlers: [
- [10, 174, 180],
- [13, 127, 129],
- [272, 285, 287],
+ [9, 138, 144],
+ [12, 97, 99],
+ [217, 227, 229],
]
---
@@ -572,78 +456,57 @@
"
frame size: 15
parameter count: 1
-bytecode array length: 379
+bytecode array length: 308
bytecodes: [
/* 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(Star), R(6),
+ B(LdrUndefined), 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),
+ B(LdaConstant), U8(2),
+ /* 77 E> */ B(LdrKeyedProperty), R(13), U8(3), 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(Star), R(0),
+ /* 74 S> */ B(LdrNamedProperty), R(0), U8(3), U8(7), R(13),
+ /* 74 E> */ B(Call), R(13), R(0), U8(1), U8(5),
+ B(Star), R(1),
+ /* 74 E> */ B(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(1), 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(JumpIfFalse), U8(7),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(1), U8(1),
+ B(LdaNamedProperty), R(1), U8(4), U8(9),
+ B(JumpIfToBooleanTrue), U8(28),
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),
+ /* 67 E> */ B(LdaNamedProperty), R(1), U8(5), U8(11),
+ B(StaNamedPropertySloppy), R(6), U8(6), U8(13),
/* 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),
+ /* 88 S> */ B(Nop),
+ /* 96 E> */ B(LdrNamedProperty), R(6), U8(6), U8(15), R(9),
B(LdaZero),
B(Star), R(8),
- B(Jump), U8(63),
- B(Jump), U8(-84),
- B(Jump), U8(47),
+ B(Jump), U8(57),
+ B(Jump), U8(-54),
+ B(Jump), U8(41),
B(Star), R(13),
B(LdaConstant), U8(7),
B(Star), R(12),
- B(Ldar), R(closure),
- B(Star), R(14),
+ B(Mov), R(closure), 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(TestEqualStrict), R(2),
B(JumpIfFalse), U8(6),
B(LdaSmi), U8(1),
B(Star), R(2),
- B(LdaContextSlot), R(context), U8(4),
- B(Star), R(12),
+ B(LdrContextSlot), R(context), U8(4), R(12),
B(CallRuntime), U16(Runtime::kReThrow), R(12), U8(1),
B(PopContext), R(7),
B(LdaSmi), U8(-1),
@@ -654,31 +517,21 @@
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(TestEqualStrict), R(2),
+ B(JumpIfTrue), U8(5),
B(LdaUndefined),
- B(TestEqualStrict), R(11),
+ B(TestEqualStrict), R(0),
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(JumpIfFalse), U8(118),
+ B(LdrNamedProperty), R(0), U8(8), U8(17), R(4),
B(LdaNull),
- B(TestEqual), R(11),
+ B(TestEqual), R(4),
B(JumpIfFalse), U8(4),
- B(Jump), U8(124),
- B(Ldar), R(2),
- B(Star), R(11),
+ B(Jump), U8(106),
B(LdaSmi), U8(1),
- B(TestEqualStrict), R(11),
- B(JumpIfFalse), U8(79),
+ B(TestEqualStrict), R(2),
+ B(JumpIfFalse), U8(75),
B(Ldar), R(4),
B(TypeOf),
B(Star), R(11),
@@ -686,44 +539,36 @@
B(TestEqualStrict), R(11),
B(JumpIfFalse), U8(4),
B(Jump), U8(18),
- B(Wide), B(LdaSmi), U16(129),
+ B(Wide), B(LdaSmi), U16(128),
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(Mov), R(4), R(12),
+ B(Mov), R(0), R(13),
+ B(InvokeIntrinsic), U8(Runtime::k_Call), R(12), U8(2),
+ B(Jump), U8(29),
B(Star), R(13),
B(LdaConstant), U8(7),
B(Star), R(12),
- B(Ldar), R(closure),
- B(Star), R(14),
+ B(Mov), R(closure), 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(Jump), U8(27),
+ B(Mov), R(4), R(11),
+ B(Mov), R(0), R(12),
+ B(InvokeIntrinsic), U8(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(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(5), 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(Jump), U8(7),
+ B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(5), U8(1),
B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(10), U8(1),
B(LdaZero),
B(TestEqualStrict), R(8),
@@ -751,11 +596,10 @@
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
- kInstanceTypeDontCare,
]
handlers: [
- [18, 174, 180],
- [21, 127, 129],
- [273, 286, 288],
+ [17, 136, 142],
+ [20, 95, 97],
+ [216, 226, 228],
]
diff --git a/test/cctest/interpreter/bytecode_expectations/FunctionLiterals.golden b/test/cctest/interpreter/bytecode_expectations/FunctionLiterals.golden
index f6b863f..b89bbd6 100644
--- a/test/cctest/interpreter/bytecode_expectations/FunctionLiterals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/FunctionLiterals.golden
@@ -31,11 +31,10 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 15
+bytecode array length: 14
bytecodes: [
/* 30 E> */ B(StackCheck),
- /* 34 S> */ B(LdaUndefined),
- B(Star), R(1),
+ /* 34 S> */ B(LdrUndefined), R(1),
B(CreateClosure), U8(0), U8(0),
B(Star), R(0),
/* 56 E> */ B(Call), R(0), R(1), U8(1), U8(1),
@@ -53,11 +52,10 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 19
+bytecode array length: 18
bytecodes: [
/* 30 E> */ B(StackCheck),
- /* 34 S> */ B(LdaUndefined),
- B(Star), R(1),
+ /* 34 S> */ B(LdrUndefined), R(1),
B(CreateClosure), U8(0), U8(0),
B(Star), R(0),
B(LdaSmi), U8(1),
diff --git a/test/cctest/interpreter/bytecode_expectations/Generators.golden b/test/cctest/interpreter/bytecode_expectations/Generators.golden
index 46a6b4a..f75b47e 100644
--- a/test/cctest/interpreter/bytecode_expectations/Generators.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Generators.golden
@@ -12,10 +12,11 @@
---
snippet: "
function* f() { }
+ f();
"
frame size: 11
parameter count: 1
-bytecode array length: 203
+bytecode array length: 204
bytecodes: [
B(Ldar), R(new_target),
B(JumpIfUndefined), U8(20),
@@ -23,34 +24,34 @@
B(Star), R(1),
B(LdaZero),
B(TestEqualStrict), R(1),
- B(JumpIfTrue), U8(57),
+ B(JumpIfTrue), U8(60),
B(LdaSmi), U8(76),
B(Star), R(2),
B(CallRuntime), U16(Runtime::kAbort), R(2), U8(1),
+ B(LdaSmi), U8(-2),
+ B(Star), R(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),
+ /* 11 E> */ B(LdrContextSlot), R(context), U8(4), R(6),
+ B(Ldar), R(6),
+ B(Mov), R(closure), R(5),
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(LdrContextSlot), R(context), U8(5), 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(CallRuntime), U16(Runtime::k_GeneratorGetInputOrDebugPos), R(6), U8(1),
B(Star), R(7),
- B(CallRuntime), U16(Runtime::kGeneratorGetResumeMode), R(6), U8(1),
+ B(CallRuntime), U16(Runtime::k_GeneratorGetResumeMode), R(6), U8(1),
B(Star), R(8),
B(LdaZero),
B(TestEqualStrict), R(8),
@@ -59,18 +60,17 @@
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(Mov), R(7), R(9),
+ B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(9), U8(2),
B(Star), R(3),
B(LdaZero),
B(Star), R(2),
- B(Jump), U8(36),
+ B(Jump), U8(35),
B(Ldar), R(7),
- B(Throw),
- B(LdaUndefined),
- B(Star), R(5),
+ /* 11 E> */ B(Throw),
+ B(LdrUndefined), R(5),
B(LdaTrue),
B(Star), R(6),
B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(5), U8(2),
@@ -86,9 +86,8 @@
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(LdrContextSlot), R(context), U8(5), R(5),
+ B(CallRuntime), U16(Runtime::k_GeneratorClose), R(5), U8(1),
B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(4), U8(1),
B(LdaZero),
B(TestEqualStrict), R(2),
@@ -112,12 +111,13 @@
constant pool: [
]
handlers: [
- [38, 139, 145],
+ [42, 141, 147],
]
---
snippet: "
function* f() { yield 42 }
+ f();
"
frame size: 11
parameter count: 1
@@ -129,37 +129,37 @@
B(Star), R(1),
B(LdaZero),
B(TestEqualStrict), R(1),
- B(JumpIfTrue), U8(63),
+ B(JumpIfTrue), U8(66),
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(LdaSmi), U8(-2),
+ B(Star), R(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),
+ /* 11 E> */ B(LdrContextSlot), R(context), U8(4), R(6),
+ B(Ldar), R(6),
+ B(Mov), R(closure), R(5),
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(LdrContextSlot), R(context), U8(5), 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(CallRuntime), U16(Runtime::k_GeneratorGetInputOrDebugPos), R(6), U8(1),
B(Star), R(7),
- B(CallRuntime), U16(Runtime::kGeneratorGetResumeMode), R(6), U8(1),
+ B(CallRuntime), U16(Runtime::k_GeneratorGetResumeMode), R(6), U8(1),
B(Star), R(8),
B(LdaZero),
B(TestEqualStrict), R(8),
@@ -168,33 +168,32 @@
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(Mov), R(7), R(9),
+ B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(9), U8(2),
B(Star), R(3),
B(LdaZero),
B(Star), R(2),
- B(Jump), U8(115),
+ B(Jump), U8(113),
B(Ldar), R(7),
- B(Throw),
+ /* 11 E> */ 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(LdrContextSlot), R(context), U8(5), 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(CallRuntime), U16(Runtime::k_GeneratorGetInputOrDebugPos), R(5), U8(1),
B(Star), R(6),
- B(CallRuntime), U16(Runtime::kGeneratorGetResumeMode), R(5), U8(1),
+ B(CallRuntime), U16(Runtime::k_GeneratorGetResumeMode), R(5), U8(1),
B(Star), R(8),
B(LdaZero),
B(TestEqualStrict), R(8),
@@ -203,18 +202,17 @@
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(Mov), R(6), R(9),
+ B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(9), U8(2),
B(Star), R(3),
B(LdaSmi), U8(1),
B(Star), R(2),
- B(Jump), U8(36),
+ B(Jump), U8(35),
B(Ldar), R(6),
- B(Throw),
- B(LdaUndefined),
- B(Star), R(5),
+ /* 16 E> */ B(Throw),
+ B(LdrUndefined), R(5),
B(LdaTrue),
B(Star), R(6),
B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(5), U8(2),
@@ -230,9 +228,8 @@
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(LdrContextSlot), R(context), U8(5), R(5),
+ B(CallRuntime), U16(Runtime::k_GeneratorClose), R(5), U8(1),
B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(4), U8(1),
B(LdaZero),
B(TestEqualStrict), R(2),
@@ -262,16 +259,17 @@
kInstanceTypeDontCare,
]
handlers: [
- [44, 224, 230],
+ [48, 225, 231],
]
---
snippet: "
function* f() { for (let x of [42]) yield x }
+ f();
"
frame size: 17
parameter count: 1
-bytecode array length: 808
+bytecode array length: 779
bytecodes: [
B(Ldar), R(new_target),
B(JumpIfUndefined), U8(26),
@@ -279,37 +277,37 @@
B(Star), R(3),
B(LdaZero),
B(TestEqualStrict), R(3),
- B(JumpIfTrue), U8(63),
+ B(JumpIfTrue), U8(66),
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(LdaSmi), U8(-2),
+ B(Star), R(3),
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),
+ /* 11 E> */ B(LdrContextSlot), R(context), U8(4), R(8),
+ B(Ldar), R(8),
+ B(Mov), R(closure), R(7),
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(LdrContextSlot), R(context), U8(5), 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(CallRuntime), U16(Runtime::k_GeneratorGetInputOrDebugPos), R(8), U8(1),
B(Star), R(9),
- B(CallRuntime), U16(Runtime::kGeneratorGetResumeMode), R(8), U8(1),
+ B(CallRuntime), U16(Runtime::k_GeneratorGetResumeMode), R(8), U8(1),
B(Star), R(10),
B(LdaZero),
B(TestEqualStrict), R(10),
@@ -318,20 +316,19 @@
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(Mov), R(9), R(11),
+ B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(11), U8(2),
B(Star), R(5),
B(LdaZero),
B(Star), R(4),
- B(JumpConstant), U8(17),
+ B(JumpConstant), U8(16),
B(Ldar), R(9),
- B(Throw),
+ /* 11 E> */ B(Throw),
B(LdaConstant), U8(0),
B(Star), R(7),
- B(Ldar), R(closure),
- B(Star), R(8),
+ B(Mov), R(closure), R(8),
B(CallRuntime), U16(Runtime::kPushBlockContext), R(7), U8(2),
B(PushContext), R(1),
B(LdaTheHole),
@@ -344,9 +341,8 @@
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),
+ B(LdaConstant), U8(2),
+ /* 30 E> */ B(LdrKeyedProperty), R(12), U8(3), 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),
@@ -358,35 +354,29 @@
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 S> */ B(LdrContextSlot), R(1), U8(7), R(13),
+ B(LdrNamedProperty), R(13), U8(4), U8(7), 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(InvokeIntrinsic), U8(Runtime::k_IsJSReceiver), R(11), U8(1),
B(ToBooleanLogicalNot),
- B(JumpIfFalse), U8(12),
- B(LdaContextSlot), R(1), U8(8),
- B(Star), R(11),
+ B(JumpIfFalse), U8(11),
+ B(LdrContextSlot), R(1), U8(8), 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(LdrContextSlot), R(1), U8(8), R(11),
+ B(LdaNamedProperty), 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(LdrContextSlot), R(1), U8(8), R(11),
+ B(LdaNamedProperty), 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(Mov), R(closure), R(12),
B(CallRuntime), U16(Runtime::kPushBlockContext), R(11), U8(2),
B(PushContext), R(2),
B(LdaTheHole),
@@ -403,17 +393,16 @@
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(LdrContextSlot), R(1), U8(5), 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(CallRuntime), U16(Runtime::k_GeneratorGetInputOrDebugPos), R(11), U8(1),
B(Star), R(12),
- B(CallRuntime), U16(Runtime::kGeneratorGetResumeMode), R(11), U8(1),
+ B(CallRuntime), U16(Runtime::k_GeneratorGetResumeMode), R(11), U8(1),
B(Star), R(14),
B(LdaZero),
B(TestEqualStrict), R(14),
@@ -422,10 +411,10 @@
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(Mov), R(12), R(15),
+ B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(15), U8(2),
B(PopContext), R(2),
B(PopContext), R(2),
B(PopContext), R(2),
@@ -436,32 +425,29 @@
B(Star), R(8),
B(LdaZero),
B(Star), R(7),
- B(Jump), U8(78),
+ B(Jump), U8(75),
B(Ldar), R(12),
- B(Throw),
+ /* 36 E> */ 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(Wide), B(Jump), U16(-222),
+ B(Jump), U8(46),
B(Star), R(12),
B(LdaConstant), U8(11),
B(Star), R(11),
- B(Ldar), R(closure),
- B(Star), R(13),
+ B(Mov), R(closure), 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(LdrContextSlot), R(1), U8(9), 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(LdrContextSlot), R(context), U8(4), R(11),
B(CallRuntime), U16(Runtime::kReThrow), R(11), U8(1),
B(PopContext), R(2),
B(LdaSmi), U8(-1),
@@ -472,32 +458,27 @@
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(LdrContextSlot), R(1), U8(9), R(10),
B(LdaZero),
B(TestEqualStrict), R(10),
- B(JumpIfTrue), U8(10),
- B(LdaContextSlot), R(1), U8(7),
- B(Star), R(10),
+ B(JumpIfTrue), U8(9),
+ B(LdrContextSlot), R(1), U8(7), 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(JumpIfFalseConstant), U8(15),
+ B(LdrContextSlot), R(1), U8(7), R(10),
+ B(LdaNamedProperty), R(10), U8(12), U8(13),
B(StaContextSlot), R(1), U8(11),
- B(LdaContextSlot), R(1), U8(11),
- B(Star), R(10),
+ B(LdrContextSlot), R(1), U8(11), 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(Jump), U8(124),
+ B(LdrContextSlot), R(1), U8(9), R(10),
B(LdaSmi), U8(1),
B(TestEqualStrict), R(10),
- B(JumpIfFalse), U8(82),
+ B(JumpIfFalse), U8(78),
B(LdaContextSlot), R(1), U8(11),
B(TypeOf),
B(Star), R(10),
@@ -505,44 +486,37 @@
B(TestEqualStrict), R(10),
B(JumpIfFalse), U8(4),
B(Jump), U8(18),
- B(Wide), B(LdaSmi), U16(129),
+ B(Wide), B(LdaSmi), U16(128),
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(LdrContextSlot), R(1), U8(11), R(11),
+ B(LdrContextSlot), R(1), U8(7), R(12),
+ B(InvokeIntrinsic), U8(Runtime::k_Call), R(11), U8(2),
+ B(Jump), U8(29),
B(Star), R(12),
B(LdaConstant), U8(11),
B(Star), R(11),
- B(Ldar), R(closure),
- B(Star), R(13),
+ B(Mov), R(closure), 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(Jump), U8(38),
+ B(LdrContextSlot), R(1), U8(11), R(10),
+ B(LdrContextSlot), R(1), U8(7), R(11),
+ B(InvokeIntrinsic), U8(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(LdrContextSlot), R(1), U8(12), R(10),
+ B(InvokeIntrinsic), U8(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(Jump), U8(11),
+ B(LdrContextSlot), R(1), U8(12), R(10),
B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(10), U8(1),
B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(9), U8(1),
B(LdaZero),
@@ -550,25 +524,22 @@
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(JumpIfTrue), U8(17),
+ B(Jump), U8(28),
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(Mov), R(8), R(5),
+ B(Jump), U8(47),
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(Mov), R(8), R(5),
+ B(Jump), U8(34),
B(PopContext), R(1),
- B(LdaUndefined),
- B(Star), R(7),
+ B(LdrUndefined), R(7),
B(LdaTrue),
B(Star), R(8),
B(CallRuntime), U16(Runtime::k_CreateIterResultObject), R(7), U8(2),
@@ -584,9 +555,8 @@
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(LdrContextSlot), R(context), U8(5), R(7),
+ B(CallRuntime), U16(Runtime::k_GeneratorClose), R(7), U8(1),
B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(6), U8(1),
B(LdaZero),
B(TestEqualStrict), R(4),
@@ -635,12 +605,11 @@
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
kInstanceTypeDontCare,
kInstanceTypeDontCare,
- kInstanceTypeDontCare,
]
handlers: [
- [44, 726, 732],
- [156, 462, 468],
- [159, 413, 415],
- [570, 585, 587],
+ [48, 698, 704],
+ [158, 452, 458],
+ [161, 406, 408],
+ [555, 567, 569],
]
diff --git a/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden b/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden
index 89d31ee..5c9524d 100644
--- a/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden
+++ b/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden
@@ -16,11 +16,10 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 14
+bytecode array length: 12
bytecodes: [
/* 26 E> */ B(StackCheck),
- /* 31 S> */ B(LdaGlobal), U8(0), U8(1),
- B(Star), R(0),
+ /* 31 S> */ B(LdrGlobal), U8(1), R(0),
B(LdaSmi), U8(1),
B(BitwiseAnd), R(0),
/* 45 E> */ B(StaGlobalSloppy), U8(0), U8(3),
@@ -40,11 +39,10 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 14
+bytecode array length: 12
bytecodes: [
/* 27 E> */ B(StackCheck),
- /* 32 S> */ B(LdaGlobal), U8(0), U8(1),
- B(Star), R(0),
+ /* 32 S> */ B(LdrGlobal), U8(1), R(0),
B(LdaSmi), U8(1),
B(Add), R(0),
/* 51 E> */ B(StaGlobalSloppy), U8(0), U8(3),
diff --git a/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden1 b/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden1
new file mode 100644
index 0000000..b44d37b
--- /dev/null
+++ b/test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden1
@@ -0,0 +1,64 @@
+#
+# Autogenerated by generate-bytecode-expectations.
+#
+
+---
+pool type: mixed
+execute: yes
+wrap: yes
+
+---
+snippet: "
+ var global = 1;
+ function f() { return global &= 1; }
+ f();
+"
+frame size: 4
+parameter count: 1
+bytecode array length: 27
+bytecodes: [
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), U8(1),
+ B(PushContext), R(1),
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 47 S> */ B(LdaSmi), U8(1),
+ /* 47 E> */ B(StaContextSlot), R(context), U8(4),
+ /* 87 S> */ B(LdrUndefined), R(3),
+ /* 87 E> */ B(Call), R(0), R(3), U8(1), U8(1),
+ B(LdaUndefined),
+ /* 92 S> */ B(Return),
+]
+constant pool: [
+ InstanceType::SHARED_FUNCTION_INFO_TYPE,
+]
+handlers: [
+]
+
+---
+snippet: "
+ unallocated = 1;
+ function f() { return unallocated += 1; }
+ f();
+"
+frame size: 3
+parameter count: 1
+bytecode array length: 20
+bytecodes: [
+ B(CreateClosure), U8(0), U8(0),
+ B(Star), R(0),
+ /* 30 E> */ B(StackCheck),
+ /* 34 S> */ B(LdaSmi), U8(1),
+ /* 46 E> */ B(StaGlobalSloppy), U8(1), U8(1),
+ /* 93 S> */ B(LdrUndefined), R(2),
+ /* 93 E> */ B(Call), R(0), R(2), U8(1), U8(3),
+ B(LdaUndefined),
+ /* 98 S> */ B(Return),
+]
+constant pool: [
+ InstanceType::SHARED_FUNCTION_INFO_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+]
+handlers: [
+]
+
diff --git a/test/cctest/interpreter/bytecode_expectations/GlobalCountOperators.golden b/test/cctest/interpreter/bytecode_expectations/GlobalCountOperators.golden
index df64018..ea50000 100644
--- a/test/cctest/interpreter/bytecode_expectations/GlobalCountOperators.golden
+++ b/test/cctest/interpreter/bytecode_expectations/GlobalCountOperators.golden
@@ -16,10 +16,10 @@
"
frame size: 0
parameter count: 1
-bytecode array length: 9
+bytecode array length: 8
bytecodes: [
/* 26 E> */ B(StackCheck),
- /* 31 S> */ B(LdaGlobal), U8(0), U8(1),
+ /* 31 S> */ B(LdaGlobal), U8(1),
B(Inc),
/* 40 E> */ B(StaGlobalSloppy), U8(0), U8(3),
/* 48 S> */ B(Return),
@@ -38,10 +38,10 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 14
+bytecode array length: 13
bytecodes: [
/* 26 E> */ B(StackCheck),
- /* 31 S> */ B(LdaGlobal), U8(0), U8(1),
+ /* 31 S> */ B(LdaGlobal), U8(1),
B(ToNumber),
B(Star), R(0),
B(Dec),
@@ -63,10 +63,10 @@
"
frame size: 0
parameter count: 1
-bytecode array length: 9
+bytecode array length: 8
bytecodes: [
/* 27 E> */ B(StackCheck),
- /* 46 S> */ B(LdaGlobal), U8(0), U8(1),
+ /* 46 S> */ B(LdaGlobal), U8(1),
B(Dec),
/* 55 E> */ B(StaGlobalStrict), U8(0), U8(3),
/* 68 S> */ B(Return),
@@ -85,10 +85,10 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 14
+bytecode array length: 13
bytecodes: [
/* 27 E> */ B(StackCheck),
- /* 32 S> */ B(LdaGlobal), U8(0), U8(1),
+ /* 32 S> */ B(LdaGlobal), U8(1),
B(ToNumber),
B(Star), R(0),
B(Inc),
diff --git a/test/cctest/interpreter/bytecode_expectations/GlobalDelete.golden b/test/cctest/interpreter/bytecode_expectations/GlobalDelete.golden
index fc86582..adead06 100644
--- a/test/cctest/interpreter/bytecode_expectations/GlobalDelete.golden
+++ b/test/cctest/interpreter/bytecode_expectations/GlobalDelete.golden
@@ -18,18 +18,16 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 11
+bytecode array length: 9
bytecodes: [
/* 32 E> */ B(StackCheck),
- /* 39 S> */ B(LdaGlobal), U8(0), U8(1),
- B(Star), R(0),
- B(LdaConstant), U8(1),
+ /* 39 S> */ B(LdrGlobal), U8(1), R(0),
+ B(LdaConstant), U8(0),
B(DeletePropertySloppy), R(0),
/* 58 S> */ B(Return),
]
constant pool: [
InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
- InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
]
handlers: [
]
@@ -45,17 +43,15 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 11
+bytecode array length: 9
bytecodes: [
/* 28 E> */ B(StackCheck),
- /* 51 S> */ B(LdaGlobal), U8(0), U8(1),
- B(Star), R(0),
+ /* 51 S> */ B(LdrGlobal), U8(1), R(0),
B(LdaSmi), U8(1),
B(DeletePropertyStrict), R(0),
/* 71 S> */ B(Return),
]
constant pool: [
- InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
]
handlers: [
]
@@ -70,13 +66,11 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 16
+bytecode array length: 14
bytecodes: [
/* 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),
+ /* 39 S> */ B(LdrContextSlot), R(context), U8(3), R(0),
+ B(LdrContextSlot), R(0), U8(2), R(1),
B(LdaConstant), U8(0),
B(DeletePropertySloppy), R(1),
/* 56 S> */ B(Return),
@@ -97,13 +91,11 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 16
+bytecode array length: 14
bytecodes: [
/* 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),
+ /* 25 S> */ B(LdrContextSlot), R(context), U8(3), R(0),
+ B(LdrContextSlot), R(0), U8(2), R(1),
B(LdaConstant), U8(0),
B(DeletePropertySloppy), R(1),
/* 42 S> */ B(Return),
diff --git a/test/cctest/interpreter/bytecode_expectations/HeapNumberConstants.golden b/test/cctest/interpreter/bytecode_expectations/HeapNumberConstants.golden
index bcc4b67..f70321a 100644
--- a/test/cctest/interpreter/bytecode_expectations/HeapNumberConstants.golden
+++ b/test/cctest/interpreter/bytecode_expectations/HeapNumberConstants.golden
@@ -35,7 +35,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 47 S> */ B(LdaConstant), U8(1),
/* 59 S> */ B(Return),
]
@@ -56,7 +56,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 48 S> */ B(LdaConstant), U8(1),
/* 61 S> */ B(Return),
]
@@ -333,519 +333,519 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 41 S> */ B(LdaConstant), U8(0),
- /* 43 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 52 S> */ B(LdaConstant), U8(1),
- /* 54 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 63 S> */ B(LdaConstant), U8(2),
- /* 65 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 74 S> */ B(LdaConstant), U8(3),
- /* 76 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 85 S> */ B(LdaConstant), U8(4),
- /* 87 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 96 S> */ B(LdaConstant), U8(5),
- /* 98 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 107 S> */ B(LdaConstant), U8(6),
- /* 109 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 118 S> */ B(LdaConstant), U8(7),
- /* 120 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 129 S> */ B(LdaConstant), U8(8),
- /* 131 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 140 S> */ B(LdaConstant), U8(9),
- /* 142 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 151 S> */ B(LdaConstant), U8(10),
- /* 153 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 162 S> */ B(LdaConstant), U8(11),
- /* 164 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 173 S> */ B(LdaConstant), U8(12),
- /* 175 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 184 S> */ B(LdaConstant), U8(13),
- /* 186 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 195 S> */ B(LdaConstant), U8(14),
- /* 197 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 206 S> */ B(LdaConstant), U8(15),
- /* 208 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 217 S> */ B(LdaConstant), U8(16),
- /* 219 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 228 S> */ B(LdaConstant), U8(17),
- /* 230 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 239 S> */ B(LdaConstant), U8(18),
- /* 241 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 250 S> */ B(LdaConstant), U8(19),
- /* 252 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 261 S> */ B(LdaConstant), U8(20),
- /* 263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 272 S> */ B(LdaConstant), U8(21),
- /* 274 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 283 S> */ B(LdaConstant), U8(22),
- /* 285 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 294 S> */ B(LdaConstant), U8(23),
- /* 296 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 305 S> */ B(LdaConstant), U8(24),
- /* 307 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 316 S> */ B(LdaConstant), U8(25),
- /* 318 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 327 S> */ B(LdaConstant), U8(26),
- /* 329 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 338 S> */ B(LdaConstant), U8(27),
- /* 340 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 349 S> */ B(LdaConstant), U8(28),
- /* 351 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 360 S> */ B(LdaConstant), U8(29),
- /* 362 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 371 S> */ B(LdaConstant), U8(30),
- /* 373 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 382 S> */ B(LdaConstant), U8(31),
- /* 384 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 393 S> */ B(LdaConstant), U8(32),
- /* 395 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 404 S> */ B(LdaConstant), U8(33),
- /* 406 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 415 S> */ B(LdaConstant), U8(34),
- /* 417 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 426 S> */ B(LdaConstant), U8(35),
- /* 428 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 437 S> */ B(LdaConstant), U8(36),
- /* 439 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 448 S> */ B(LdaConstant), U8(37),
- /* 450 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 459 S> */ B(LdaConstant), U8(38),
- /* 461 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 470 S> */ B(LdaConstant), U8(39),
- /* 472 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 481 S> */ B(LdaConstant), U8(40),
- /* 483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 492 S> */ B(LdaConstant), U8(41),
- /* 494 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 503 S> */ B(LdaConstant), U8(42),
- /* 505 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 514 S> */ B(LdaConstant), U8(43),
- /* 516 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 525 S> */ B(LdaConstant), U8(44),
- /* 527 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 536 S> */ B(LdaConstant), U8(45),
- /* 538 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 547 S> */ B(LdaConstant), U8(46),
- /* 549 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 558 S> */ B(LdaConstant), U8(47),
- /* 560 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 569 S> */ B(LdaConstant), U8(48),
- /* 571 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 580 S> */ B(LdaConstant), U8(49),
- /* 582 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 591 S> */ B(LdaConstant), U8(50),
- /* 593 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 602 S> */ B(LdaConstant), U8(51),
- /* 604 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 613 S> */ B(LdaConstant), U8(52),
- /* 615 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 624 S> */ B(LdaConstant), U8(53),
- /* 626 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 635 S> */ B(LdaConstant), U8(54),
- /* 637 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 646 S> */ B(LdaConstant), U8(55),
- /* 648 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 657 S> */ B(LdaConstant), U8(56),
- /* 659 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 668 S> */ B(LdaConstant), U8(57),
- /* 670 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 679 S> */ B(LdaConstant), U8(58),
- /* 681 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 690 S> */ B(LdaConstant), U8(59),
- /* 692 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 701 S> */ B(LdaConstant), U8(60),
- /* 703 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 712 S> */ B(LdaConstant), U8(61),
- /* 714 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 723 S> */ B(LdaConstant), U8(62),
- /* 725 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 734 S> */ B(LdaConstant), U8(63),
- /* 736 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 745 S> */ B(LdaConstant), U8(64),
- /* 747 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 756 S> */ B(LdaConstant), U8(65),
- /* 758 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 767 S> */ B(LdaConstant), U8(66),
- /* 769 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 778 S> */ B(LdaConstant), U8(67),
- /* 780 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 789 S> */ B(LdaConstant), U8(68),
- /* 791 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 800 S> */ B(LdaConstant), U8(69),
- /* 802 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 811 S> */ B(LdaConstant), U8(70),
- /* 813 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 822 S> */ B(LdaConstant), U8(71),
- /* 824 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 833 S> */ B(LdaConstant), U8(72),
- /* 835 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 844 S> */ B(LdaConstant), U8(73),
- /* 846 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 855 S> */ B(LdaConstant), U8(74),
- /* 857 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 866 S> */ B(LdaConstant), U8(75),
- /* 868 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 877 S> */ B(LdaConstant), U8(76),
- /* 879 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 888 S> */ B(LdaConstant), U8(77),
- /* 890 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 899 S> */ B(LdaConstant), U8(78),
- /* 901 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 910 S> */ B(LdaConstant), U8(79),
- /* 912 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 921 S> */ B(LdaConstant), U8(80),
- /* 923 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 932 S> */ B(LdaConstant), U8(81),
- /* 934 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 943 S> */ B(LdaConstant), U8(82),
- /* 945 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 954 S> */ B(LdaConstant), U8(83),
- /* 956 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 965 S> */ B(LdaConstant), U8(84),
- /* 967 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 976 S> */ B(LdaConstant), U8(85),
- /* 978 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 987 S> */ B(LdaConstant), U8(86),
- /* 989 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 998 S> */ B(LdaConstant), U8(87),
- /* 1000 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1009 S> */ B(LdaConstant), U8(88),
- /* 1011 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1020 S> */ B(LdaConstant), U8(89),
- /* 1022 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1031 S> */ B(LdaConstant), U8(90),
- /* 1033 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1042 S> */ B(LdaConstant), U8(91),
- /* 1044 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1053 S> */ B(LdaConstant), U8(92),
- /* 1055 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1064 S> */ B(LdaConstant), U8(93),
- /* 1066 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1075 S> */ B(LdaConstant), U8(94),
- /* 1077 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1086 S> */ B(LdaConstant), U8(95),
- /* 1088 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1097 S> */ B(LdaConstant), U8(96),
- /* 1099 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1108 S> */ B(LdaConstant), U8(97),
- /* 1110 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1119 S> */ B(LdaConstant), U8(98),
- /* 1121 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1130 S> */ B(LdaConstant), U8(99),
- /* 1132 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1141 S> */ B(LdaConstant), U8(100),
- /* 1143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1152 S> */ B(LdaConstant), U8(101),
- /* 1154 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1163 S> */ B(LdaConstant), U8(102),
- /* 1165 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1174 S> */ B(LdaConstant), U8(103),
- /* 1176 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1185 S> */ B(LdaConstant), U8(104),
- /* 1187 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1196 S> */ B(LdaConstant), U8(105),
- /* 1198 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1207 S> */ B(LdaConstant), U8(106),
- /* 1209 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1218 S> */ B(LdaConstant), U8(107),
- /* 1220 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1229 S> */ B(LdaConstant), U8(108),
- /* 1231 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1240 S> */ B(LdaConstant), U8(109),
- /* 1242 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1251 S> */ B(LdaConstant), U8(110),
- /* 1253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1262 S> */ B(LdaConstant), U8(111),
- /* 1264 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1273 S> */ B(LdaConstant), U8(112),
- /* 1275 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1284 S> */ B(LdaConstant), U8(113),
- /* 1286 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1295 S> */ B(LdaConstant), U8(114),
- /* 1297 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1306 S> */ B(LdaConstant), U8(115),
- /* 1308 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1317 S> */ B(LdaConstant), U8(116),
- /* 1319 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1328 S> */ B(LdaConstant), U8(117),
- /* 1330 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1339 S> */ B(LdaConstant), U8(118),
- /* 1341 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1350 S> */ B(LdaConstant), U8(119),
- /* 1352 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1361 S> */ B(LdaConstant), U8(120),
- /* 1363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1372 S> */ B(LdaConstant), U8(121),
- /* 1374 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1383 S> */ B(LdaConstant), U8(122),
- /* 1385 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1394 S> */ B(LdaConstant), U8(123),
- /* 1396 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1405 S> */ B(LdaConstant), U8(124),
- /* 1407 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1416 S> */ B(LdaConstant), U8(125),
- /* 1418 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1427 S> */ B(LdaConstant), U8(126),
- /* 1429 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1438 S> */ B(LdaConstant), U8(127),
- /* 1440 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1449 S> */ B(LdaConstant), U8(128),
- /* 1451 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1460 S> */ B(LdaConstant), U8(129),
- /* 1462 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1471 S> */ B(LdaConstant), U8(130),
- /* 1473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1482 S> */ B(LdaConstant), U8(131),
- /* 1484 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1493 S> */ B(LdaConstant), U8(132),
- /* 1495 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1504 S> */ B(LdaConstant), U8(133),
- /* 1506 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1515 S> */ B(LdaConstant), U8(134),
- /* 1517 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1526 S> */ B(LdaConstant), U8(135),
- /* 1528 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1537 S> */ B(LdaConstant), U8(136),
- /* 1539 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1548 S> */ B(LdaConstant), U8(137),
- /* 1550 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1559 S> */ B(LdaConstant), U8(138),
- /* 1561 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1570 S> */ B(LdaConstant), U8(139),
- /* 1572 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1581 S> */ B(LdaConstant), U8(140),
- /* 1583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1592 S> */ B(LdaConstant), U8(141),
- /* 1594 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1603 S> */ B(LdaConstant), U8(142),
- /* 1605 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1614 S> */ B(LdaConstant), U8(143),
- /* 1616 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1625 S> */ B(LdaConstant), U8(144),
- /* 1627 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1636 S> */ B(LdaConstant), U8(145),
- /* 1638 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1647 S> */ B(LdaConstant), U8(146),
- /* 1649 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1658 S> */ B(LdaConstant), U8(147),
- /* 1660 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1669 S> */ B(LdaConstant), U8(148),
- /* 1671 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1680 S> */ B(LdaConstant), U8(149),
- /* 1682 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1691 S> */ B(LdaConstant), U8(150),
- /* 1693 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1702 S> */ B(LdaConstant), U8(151),
- /* 1704 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1713 S> */ B(LdaConstant), U8(152),
- /* 1715 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1724 S> */ B(LdaConstant), U8(153),
- /* 1726 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1735 S> */ B(LdaConstant), U8(154),
- /* 1737 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1746 S> */ B(LdaConstant), U8(155),
- /* 1748 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1757 S> */ B(LdaConstant), U8(156),
- /* 1759 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1768 S> */ B(LdaConstant), U8(157),
- /* 1770 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1779 S> */ B(LdaConstant), U8(158),
- /* 1781 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1790 S> */ B(LdaConstant), U8(159),
- /* 1792 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1801 S> */ B(LdaConstant), U8(160),
- /* 1803 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1812 S> */ B(LdaConstant), U8(161),
- /* 1814 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1823 S> */ B(LdaConstant), U8(162),
- /* 1825 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1834 S> */ B(LdaConstant), U8(163),
- /* 1836 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1845 S> */ B(LdaConstant), U8(164),
- /* 1847 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1856 S> */ B(LdaConstant), U8(165),
- /* 1858 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1867 S> */ B(LdaConstant), U8(166),
- /* 1869 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1878 S> */ B(LdaConstant), U8(167),
- /* 1880 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1889 S> */ B(LdaConstant), U8(168),
- /* 1891 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1900 S> */ B(LdaConstant), U8(169),
- /* 1902 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1911 S> */ B(LdaConstant), U8(170),
- /* 1913 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1922 S> */ B(LdaConstant), U8(171),
- /* 1924 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1933 S> */ B(LdaConstant), U8(172),
- /* 1935 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1944 S> */ B(LdaConstant), U8(173),
- /* 1946 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1955 S> */ B(LdaConstant), U8(174),
- /* 1957 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1966 S> */ B(LdaConstant), U8(175),
- /* 1968 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1977 S> */ B(LdaConstant), U8(176),
- /* 1979 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1988 S> */ B(LdaConstant), U8(177),
- /* 1990 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1999 S> */ B(LdaConstant), U8(178),
- /* 2001 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2010 S> */ B(LdaConstant), U8(179),
- /* 2012 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2021 S> */ B(LdaConstant), U8(180),
- /* 2023 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2032 S> */ B(LdaConstant), U8(181),
- /* 2034 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2043 S> */ B(LdaConstant), U8(182),
- /* 2045 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2054 S> */ B(LdaConstant), U8(183),
- /* 2056 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2065 S> */ B(LdaConstant), U8(184),
- /* 2067 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2076 S> */ B(LdaConstant), U8(185),
- /* 2078 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2087 S> */ B(LdaConstant), U8(186),
- /* 2089 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2098 S> */ B(LdaConstant), U8(187),
- /* 2100 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2109 S> */ B(LdaConstant), U8(188),
- /* 2111 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2120 S> */ B(LdaConstant), U8(189),
- /* 2122 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2131 S> */ B(LdaConstant), U8(190),
- /* 2133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2142 S> */ B(LdaConstant), U8(191),
- /* 2144 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2153 S> */ B(LdaConstant), U8(192),
- /* 2155 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2164 S> */ B(LdaConstant), U8(193),
- /* 2166 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2175 S> */ B(LdaConstant), U8(194),
- /* 2177 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2186 S> */ B(LdaConstant), U8(195),
- /* 2188 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2197 S> */ B(LdaConstant), U8(196),
- /* 2199 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2208 S> */ B(LdaConstant), U8(197),
- /* 2210 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2219 S> */ B(LdaConstant), U8(198),
- /* 2221 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2230 S> */ B(LdaConstant), U8(199),
- /* 2232 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2241 S> */ B(LdaConstant), U8(200),
- /* 2243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2252 S> */ B(LdaConstant), U8(201),
- /* 2254 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2263 S> */ B(LdaConstant), U8(202),
- /* 2265 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2274 S> */ B(LdaConstant), U8(203),
- /* 2276 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2285 S> */ B(LdaConstant), U8(204),
- /* 2287 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2296 S> */ B(LdaConstant), U8(205),
- /* 2298 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2307 S> */ B(LdaConstant), U8(206),
- /* 2309 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2318 S> */ B(LdaConstant), U8(207),
- /* 2320 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2329 S> */ B(LdaConstant), U8(208),
- /* 2331 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2340 S> */ B(LdaConstant), U8(209),
- /* 2342 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2351 S> */ B(LdaConstant), U8(210),
- /* 2353 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2362 S> */ B(LdaConstant), U8(211),
- /* 2364 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2373 S> */ B(LdaConstant), U8(212),
- /* 2375 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2384 S> */ B(LdaConstant), U8(213),
- /* 2386 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2395 S> */ B(LdaConstant), U8(214),
- /* 2397 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2406 S> */ B(LdaConstant), U8(215),
- /* 2408 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2417 S> */ B(LdaConstant), U8(216),
- /* 2419 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2428 S> */ B(LdaConstant), U8(217),
- /* 2430 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2439 S> */ B(LdaConstant), U8(218),
- /* 2441 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2450 S> */ B(LdaConstant), U8(219),
- /* 2452 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2461 S> */ B(LdaConstant), U8(220),
- /* 2463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2472 S> */ B(LdaConstant), U8(221),
- /* 2474 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2483 S> */ B(LdaConstant), U8(222),
- /* 2485 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2494 S> */ B(LdaConstant), U8(223),
- /* 2496 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2505 S> */ B(LdaConstant), U8(224),
- /* 2507 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2516 S> */ B(LdaConstant), U8(225),
- /* 2518 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2527 S> */ B(LdaConstant), U8(226),
- /* 2529 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2538 S> */ B(LdaConstant), U8(227),
- /* 2540 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2549 S> */ B(LdaConstant), U8(228),
- /* 2551 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2560 S> */ B(LdaConstant), U8(229),
- /* 2562 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2571 S> */ B(LdaConstant), U8(230),
- /* 2573 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2582 S> */ B(LdaConstant), U8(231),
- /* 2584 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2593 S> */ B(LdaConstant), U8(232),
- /* 2595 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2604 S> */ B(LdaConstant), U8(233),
- /* 2606 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2615 S> */ B(LdaConstant), U8(234),
- /* 2617 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2626 S> */ B(LdaConstant), U8(235),
- /* 2628 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2637 S> */ B(LdaConstant), U8(236),
- /* 2639 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2648 S> */ B(LdaConstant), U8(237),
- /* 2650 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2659 S> */ B(LdaConstant), U8(238),
- /* 2661 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2670 S> */ B(LdaConstant), U8(239),
- /* 2672 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2681 S> */ B(LdaConstant), U8(240),
- /* 2683 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2692 S> */ B(LdaConstant), U8(241),
- /* 2694 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2703 S> */ B(LdaConstant), U8(242),
- /* 2705 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2714 S> */ B(LdaConstant), U8(243),
- /* 2716 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2725 S> */ B(LdaConstant), U8(244),
- /* 2727 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2736 S> */ B(LdaConstant), U8(245),
- /* 2738 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2747 S> */ B(LdaConstant), U8(246),
- /* 2749 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2758 S> */ B(LdaConstant), U8(247),
- /* 2760 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2769 S> */ B(LdaConstant), U8(248),
- /* 2771 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2780 S> */ B(LdaConstant), U8(249),
- /* 2782 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2791 S> */ B(LdaConstant), U8(250),
- /* 2793 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2802 S> */ B(LdaConstant), U8(251),
- /* 2804 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2813 S> */ B(LdaConstant), U8(252),
- /* 2815 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2824 S> */ B(LdaConstant), U8(253),
- /* 2826 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2835 S> */ B(LdaConstant), U8(254),
- /* 2837 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2846 S> */ B(LdaConstant), U8(255),
- /* 2848 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2857 S> */ B(Wide), B(LdaConstant), U16(256),
- /* 2859 E> */ B(Star), R(0),
+ B(Star), R(0),
B(LdaUndefined),
/* 2867 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/IfConditions.golden b/test/cctest/interpreter/bytecode_expectations/IfConditions.golden
index 2d66970..98c8229 100644
--- a/test/cctest/interpreter/bytecode_expectations/IfConditions.golden
+++ b/test/cctest/interpreter/bytecode_expectations/IfConditions.golden
@@ -116,17 +116,16 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 24
+bytecode array length: 23
bytecodes: [
/* 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(Star), R(0),
+ /* 30 S> */ B(JumpIfToBooleanFalse), U8(13),
+ /* 43 S> */ B(LdaSmi), U8(1),
+ B(Add), R(0),
+ B(Mov), R(0), R(1),
+ B(Star), R(0),
B(Jump), U8(5),
/* 66 S> */ B(LdaSmi), U8(2),
/* 80 S> */ B(Return),
@@ -149,15 +148,13 @@
};
f(99);
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 22
+bytecode array length: 18
bytecodes: [
/* 10 E> */ B(StackCheck),
- /* 18 S> */ B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaZero),
- /* 24 E> */ B(TestLessThanOrEqual), R(0),
+ /* 18 S> */ B(LdaZero),
+ /* 24 E> */ B(TestLessThanOrEqual), R(arg0),
B(JumpIfFalse), U8(7),
/* 36 S> */ B(Wide), B(LdaSmi), U16(200),
/* 80 S> */ B(Return),
@@ -175,15 +172,13 @@
snippet: "
function f(a, b) { if (a in b) { return 200; } }f('prop', { prop: 'yes'});
"
-frame size: 1
+frame size: 0
parameter count: 3
-bytecode array length: 18
+bytecode array length: 14
bytecodes: [
/* 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),
+ /* 19 S> */ B(Ldar), R(arg1),
+ /* 25 E> */ B(TestIn), R(arg0),
B(JumpIfFalse), U8(7),
/* 33 S> */ B(Wide), B(LdaSmi), U16(200),
/* 47 S> */ B(Return),
@@ -264,149 +259,146 @@
b = a; a = b;
return 200; } else { return -200; } } f(0.001);
"
-frame size: 3
+frame size: 2
parameter count: 2
-bytecode array length: 287
+bytecode array length: 409
bytecodes: [
/* 10 E> */ B(StackCheck),
/* 24 S> */ B(LdaZero),
- /* 24 E> */ B(Star), R(0),
+ 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(Star), R(1),
+ /* 38 S> */ B(LdaConstant), U8(0),
+ /* 44 E> */ B(TestEqualStrict), R(0),
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),
+ /* 58 S> */ B(Mov), R(0), R(1),
+ /* 65 S> */ B(Mov), R(1), R(0),
+ /* 74 S> */ B(Mov), R(0), R(1),
+ /* 81 S> */ B(Mov), R(1), R(0),
+ /* 90 S> */ B(Mov), R(0), R(1),
+ /* 97 S> */ B(Mov), R(1), R(0),
+ /* 106 S> */ B(Mov), R(0), R(1),
+ /* 113 S> */ B(Mov), R(1), R(0),
+ /* 122 S> */ B(Mov), R(0), R(1),
+ /* 129 S> */ B(Mov), R(1), R(0),
+ /* 138 S> */ B(Mov), R(0), R(1),
+ /* 145 S> */ B(Mov), R(1), R(0),
+ /* 154 S> */ B(Mov), R(0), R(1),
+ /* 161 S> */ B(Mov), R(1), R(0),
+ /* 170 S> */ B(Mov), R(0), R(1),
+ /* 177 S> */ B(Mov), R(1), R(0),
+ /* 186 S> */ B(Mov), R(0), R(1),
+ /* 193 S> */ B(Mov), R(1), R(0),
+ /* 202 S> */ B(Mov), R(0), R(1),
+ /* 209 S> */ B(Mov), R(1), R(0),
+ /* 218 S> */ B(Mov), R(0), R(1),
+ /* 225 S> */ B(Mov), R(1), R(0),
+ /* 234 S> */ B(Mov), R(0), R(1),
+ /* 241 S> */ B(Mov), R(1), R(0),
+ /* 250 S> */ B(Mov), R(0), R(1),
+ /* 257 S> */ B(Mov), R(1), R(0),
+ /* 266 S> */ B(Mov), R(0), R(1),
+ /* 273 S> */ B(Mov), R(1), R(0),
+ /* 282 S> */ B(Mov), R(0), R(1),
+ /* 289 S> */ B(Mov), R(1), R(0),
+ /* 298 S> */ B(Mov), R(0), R(1),
+ /* 305 S> */ B(Mov), R(1), R(0),
+ /* 314 S> */ B(Mov), R(0), R(1),
+ /* 321 S> */ B(Mov), R(1), R(0),
+ /* 330 S> */ B(Mov), R(0), R(1),
+ /* 337 S> */ B(Mov), R(1), R(0),
+ /* 346 S> */ B(Mov), R(0), R(1),
+ /* 353 S> */ B(Mov), R(1), R(0),
+ /* 362 S> */ B(Mov), R(0), R(1),
+ /* 369 S> */ B(Mov), R(1), R(0),
+ /* 378 S> */ B(Mov), R(0), R(1),
+ /* 385 S> */ B(Mov), R(1), R(0),
+ /* 394 S> */ B(Mov), R(0), R(1),
+ /* 401 S> */ B(Mov), R(1), R(0),
+ /* 410 S> */ B(Mov), R(0), R(1),
+ /* 417 S> */ B(Mov), R(1), R(0),
+ /* 426 S> */ B(Mov), R(0), R(1),
+ /* 433 S> */ B(Mov), R(1), R(0),
+ /* 442 S> */ B(Mov), R(0), R(1),
+ /* 449 S> */ B(Mov), R(1), R(0),
+ /* 458 S> */ B(Mov), R(0), R(1),
+ /* 465 S> */ B(Mov), R(1), R(0),
+ /* 474 S> */ B(Mov), R(0), R(1),
+ /* 481 S> */ B(Mov), R(1), R(0),
+ /* 490 S> */ B(Mov), R(0), R(1),
+ /* 497 S> */ B(Mov), R(1), R(0),
+ /* 506 S> */ B(Mov), R(0), R(1),
+ /* 513 S> */ B(Mov), R(1), R(0),
+ /* 522 S> */ B(Mov), R(0), R(1),
+ /* 529 S> */ B(Mov), R(1), R(0),
+ /* 538 S> */ B(Mov), R(0), R(1),
+ /* 545 S> */ B(Mov), R(1), R(0),
+ /* 554 S> */ B(Mov), R(0), R(1),
+ /* 561 S> */ B(Mov), R(1), R(0),
+ /* 570 S> */ B(Mov), R(0), R(1),
+ /* 577 S> */ B(Mov), R(1), R(0),
+ /* 586 S> */ B(Mov), R(0), R(1),
+ /* 593 S> */ B(Mov), R(1), R(0),
+ /* 602 S> */ B(Mov), R(0), R(1),
+ /* 609 S> */ B(Mov), R(1), R(0),
+ /* 618 S> */ B(Mov), R(0), R(1),
+ /* 625 S> */ B(Mov), R(1), R(0),
+ /* 634 S> */ B(Mov), R(0), R(1),
+ /* 641 S> */ B(Mov), R(1), R(0),
+ /* 650 S> */ B(Mov), R(0), R(1),
+ /* 657 S> */ B(Mov), R(1), R(0),
+ /* 666 S> */ B(Mov), R(0), R(1),
+ /* 673 S> */ B(Mov), R(1), R(0),
+ /* 682 S> */ B(Mov), R(0), R(1),
+ /* 689 S> */ B(Mov), R(1), R(0),
+ /* 698 S> */ B(Mov), R(0), R(1),
+ /* 705 S> */ B(Mov), R(1), R(0),
+ /* 714 S> */ B(Mov), R(0), R(1),
+ /* 721 S> */ B(Mov), R(1), R(0),
+ /* 730 S> */ B(Mov), R(0), R(1),
+ /* 737 S> */ B(Mov), R(1), R(0),
+ /* 746 S> */ B(Mov), R(0), R(1),
+ /* 753 S> */ B(Mov), R(1), R(0),
+ /* 762 S> */ B(Mov), R(0), R(1),
+ /* 769 S> */ B(Mov), R(1), R(0),
+ /* 778 S> */ B(Mov), R(0), R(1),
+ /* 785 S> */ B(Mov), R(1), R(0),
+ /* 794 S> */ B(Mov), R(0), R(1),
+ /* 801 S> */ B(Mov), R(1), R(0),
+ /* 810 S> */ B(Mov), R(0), R(1),
+ /* 817 S> */ B(Mov), R(1), R(0),
+ /* 826 S> */ B(Mov), R(0), R(1),
+ /* 833 S> */ B(Mov), R(1), R(0),
+ /* 842 S> */ B(Mov), R(0), R(1),
+ /* 849 S> */ B(Mov), R(1), R(0),
+ /* 858 S> */ B(Mov), R(0), R(1),
+ /* 865 S> */ B(Mov), R(1), R(0),
+ /* 874 S> */ B(Mov), R(0), R(1),
+ /* 881 S> */ B(Mov), R(1), R(0),
+ /* 890 S> */ B(Mov), R(0), R(1),
+ /* 897 S> */ B(Mov), R(1), R(0),
+ /* 906 S> */ B(Mov), R(0), R(1),
+ /* 913 S> */ B(Mov), R(1), R(0),
+ /* 922 S> */ B(Mov), R(0), R(1),
+ /* 929 S> */ B(Mov), R(1), R(0),
+ /* 938 S> */ B(Mov), R(0), R(1),
+ /* 945 S> */ B(Mov), R(1), R(0),
+ /* 954 S> */ B(Mov), R(0), R(1),
+ /* 961 S> */ B(Mov), R(1), R(0),
+ /* 970 S> */ B(Mov), R(0), R(1),
+ /* 977 S> */ B(Mov), R(1), R(0),
+ /* 986 S> */ B(Mov), R(0), R(1),
+ /* 993 S> */ B(Mov), R(1), R(0),
+ /* 1002 S> */ B(Mov), R(0), R(1),
+ /* 1009 S> */ B(Mov), R(1), R(0),
+ /* 1018 S> */ B(Mov), R(0), R(1),
+ /* 1025 S> */ B(Mov), R(1), R(0),
+ /* 1034 S> */ B(Mov), R(0), R(1),
+ /* 1041 S> */ B(Mov), R(1), R(0),
+ /* 1050 S> */ B(Mov), R(0), R(1),
+ /* 1057 S> */ B(Mov), R(1), R(0),
+ /* 1066 S> */ B(Mov), R(0), R(1),
+ /* 1073 S> */ B(Mov), R(1), R(0),
/* 1081 S> */ B(Wide), B(LdaSmi), U16(200),
/* 1117 S> */ B(Return),
/* 1102 S> */ B(Wide), B(LdaSmi), U16(-200),
@@ -496,144 +488,143 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 281
+bytecode array length: 407
bytecodes: [
/* 10 E> */ B(StackCheck),
/* 25 S> */ B(LdaZero),
- /* 25 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 36 S> */ B(LdaZero),
- /* 36 E> */ B(Star), R(1),
+ 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),
+ /* 52 S> */ B(Mov), R(0), R(1),
+ /* 59 S> */ B(Mov), R(1), R(0),
+ /* 68 S> */ B(Mov), R(0), R(1),
+ /* 75 S> */ B(Mov), R(1), R(0),
+ /* 84 S> */ B(Mov), R(0), R(1),
+ /* 91 S> */ B(Mov), R(1), R(0),
+ /* 100 S> */ B(Mov), R(0), R(1),
+ /* 107 S> */ B(Mov), R(1), R(0),
+ /* 116 S> */ B(Mov), R(0), R(1),
+ /* 123 S> */ B(Mov), R(1), R(0),
+ /* 132 S> */ B(Mov), R(0), R(1),
+ /* 139 S> */ B(Mov), R(1), R(0),
+ /* 148 S> */ B(Mov), R(0), R(1),
+ /* 155 S> */ B(Mov), R(1), R(0),
+ /* 164 S> */ B(Mov), R(0), R(1),
+ /* 171 S> */ B(Mov), R(1), R(0),
+ /* 180 S> */ B(Mov), R(0), R(1),
+ /* 187 S> */ B(Mov), R(1), R(0),
+ /* 196 S> */ B(Mov), R(0), R(1),
+ /* 203 S> */ B(Mov), R(1), R(0),
+ /* 212 S> */ B(Mov), R(0), R(1),
+ /* 219 S> */ B(Mov), R(1), R(0),
+ /* 228 S> */ B(Mov), R(0), R(1),
+ /* 235 S> */ B(Mov), R(1), R(0),
+ /* 244 S> */ B(Mov), R(0), R(1),
+ /* 251 S> */ B(Mov), R(1), R(0),
+ /* 260 S> */ B(Mov), R(0), R(1),
+ /* 267 S> */ B(Mov), R(1), R(0),
+ /* 276 S> */ B(Mov), R(0), R(1),
+ /* 283 S> */ B(Mov), R(1), R(0),
+ /* 292 S> */ B(Mov), R(0), R(1),
+ /* 299 S> */ B(Mov), R(1), R(0),
+ /* 308 S> */ B(Mov), R(0), R(1),
+ /* 315 S> */ B(Mov), R(1), R(0),
+ /* 324 S> */ B(Mov), R(0), R(1),
+ /* 331 S> */ B(Mov), R(1), R(0),
+ /* 340 S> */ B(Mov), R(0), R(1),
+ /* 347 S> */ B(Mov), R(1), R(0),
+ /* 356 S> */ B(Mov), R(0), R(1),
+ /* 363 S> */ B(Mov), R(1), R(0),
+ /* 372 S> */ B(Mov), R(0), R(1),
+ /* 379 S> */ B(Mov), R(1), R(0),
+ /* 388 S> */ B(Mov), R(0), R(1),
+ /* 395 S> */ B(Mov), R(1), R(0),
+ /* 404 S> */ B(Mov), R(0), R(1),
+ /* 411 S> */ B(Mov), R(1), R(0),
+ /* 420 S> */ B(Mov), R(0), R(1),
+ /* 427 S> */ B(Mov), R(1), R(0),
+ /* 436 S> */ B(Mov), R(0), R(1),
+ /* 443 S> */ B(Mov), R(1), R(0),
+ /* 452 S> */ B(Mov), R(0), R(1),
+ /* 459 S> */ B(Mov), R(1), R(0),
+ /* 468 S> */ B(Mov), R(0), R(1),
+ /* 475 S> */ B(Mov), R(1), R(0),
+ /* 484 S> */ B(Mov), R(0), R(1),
+ /* 491 S> */ B(Mov), R(1), R(0),
+ /* 500 S> */ B(Mov), R(0), R(1),
+ /* 507 S> */ B(Mov), R(1), R(0),
+ /* 516 S> */ B(Mov), R(0), R(1),
+ /* 523 S> */ B(Mov), R(1), R(0),
+ /* 532 S> */ B(Mov), R(0), R(1),
+ /* 539 S> */ B(Mov), R(1), R(0),
+ /* 548 S> */ B(Mov), R(0), R(1),
+ /* 555 S> */ B(Mov), R(1), R(0),
+ /* 564 S> */ B(Mov), R(0), R(1),
+ /* 571 S> */ B(Mov), R(1), R(0),
+ /* 580 S> */ B(Mov), R(0), R(1),
+ /* 587 S> */ B(Mov), R(1), R(0),
+ /* 596 S> */ B(Mov), R(0), R(1),
+ /* 603 S> */ B(Mov), R(1), R(0),
+ /* 612 S> */ B(Mov), R(0), R(1),
+ /* 619 S> */ B(Mov), R(1), R(0),
+ /* 628 S> */ B(Mov), R(0), R(1),
+ /* 635 S> */ B(Mov), R(1), R(0),
+ /* 644 S> */ B(Mov), R(0), R(1),
+ /* 651 S> */ B(Mov), R(1), R(0),
+ /* 660 S> */ B(Mov), R(0), R(1),
+ /* 667 S> */ B(Mov), R(1), R(0),
+ /* 676 S> */ B(Mov), R(0), R(1),
+ /* 683 S> */ B(Mov), R(1), R(0),
+ /* 692 S> */ B(Mov), R(0), R(1),
+ /* 699 S> */ B(Mov), R(1), R(0),
+ /* 708 S> */ B(Mov), R(0), R(1),
+ /* 715 S> */ B(Mov), R(1), R(0),
+ /* 724 S> */ B(Mov), R(0), R(1),
+ /* 731 S> */ B(Mov), R(1), R(0),
+ /* 740 S> */ B(Mov), R(0), R(1),
+ /* 747 S> */ B(Mov), R(1), R(0),
+ /* 756 S> */ B(Mov), R(0), R(1),
+ /* 763 S> */ B(Mov), R(1), R(0),
+ /* 772 S> */ B(Mov), R(0), R(1),
+ /* 779 S> */ B(Mov), R(1), R(0),
+ /* 788 S> */ B(Mov), R(0), R(1),
+ /* 795 S> */ B(Mov), R(1), R(0),
+ /* 804 S> */ B(Mov), R(0), R(1),
+ /* 811 S> */ B(Mov), R(1), R(0),
+ /* 820 S> */ B(Mov), R(0), R(1),
+ /* 827 S> */ B(Mov), R(1), R(0),
+ /* 836 S> */ B(Mov), R(0), R(1),
+ /* 843 S> */ B(Mov), R(1), R(0),
+ /* 852 S> */ B(Mov), R(0), R(1),
+ /* 859 S> */ B(Mov), R(1), R(0),
+ /* 868 S> */ B(Mov), R(0), R(1),
+ /* 875 S> */ B(Mov), R(1), R(0),
+ /* 884 S> */ B(Mov), R(0), R(1),
+ /* 891 S> */ B(Mov), R(1), R(0),
+ /* 900 S> */ B(Mov), R(0), R(1),
+ /* 907 S> */ B(Mov), R(1), R(0),
+ /* 916 S> */ B(Mov), R(0), R(1),
+ /* 923 S> */ B(Mov), R(1), R(0),
+ /* 932 S> */ B(Mov), R(0), R(1),
+ /* 939 S> */ B(Mov), R(1), R(0),
+ /* 948 S> */ B(Mov), R(0), R(1),
+ /* 955 S> */ B(Mov), R(1), R(0),
+ /* 964 S> */ B(Mov), R(0), R(1),
+ /* 971 S> */ B(Mov), R(1), R(0),
+ /* 980 S> */ B(Mov), R(0), R(1),
+ /* 987 S> */ B(Mov), R(1), R(0),
+ /* 996 S> */ B(Mov), R(0), R(1),
+ /* 1003 S> */ B(Mov), R(1), R(0),
+ /* 1012 S> */ B(Mov), R(0), R(1),
+ /* 1019 S> */ B(Mov), R(1), R(0),
+ /* 1028 S> */ B(Mov), R(0), R(1),
+ /* 1035 S> */ B(Mov), R(1), R(0),
+ /* 1044 S> */ B(Mov), R(0), R(1),
+ /* 1051 S> */ B(Mov), R(1), R(0),
+ /* 1060 S> */ B(Mov), R(0), R(1),
+ /* 1067 S> */ B(Mov), R(1), R(0),
/* 1076 S> */ B(Wide), B(LdaSmi), U16(200),
/* 1112 S> */ B(Return),
/* 1097 S> */ B(Wide), B(LdaSmi), U16(-200),
@@ -662,64 +653,48 @@
}
f(1, 1);
"
-frame size: 1
+frame size: 0
parameter count: 3
-bytecode array length: 107
+bytecode array length: 75
bytecodes: [
/* 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),
+ /* 21 S> */ B(Ldar), R(arg1),
+ /* 27 E> */ B(TestEqual), R(arg0),
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),
+ /* 49 S> */ B(Ldar), R(arg1),
+ /* 55 E> */ B(TestEqualStrict), R(arg0),
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),
+ /* 78 S> */ B(Ldar), R(arg1),
+ /* 84 E> */ B(TestLessThan), R(arg0),
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),
+ /* 105 S> */ B(Ldar), R(arg1),
+ /* 111 E> */ B(TestGreaterThan), R(arg0),
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),
+ /* 132 S> */ B(Ldar), R(arg1),
+ /* 138 E> */ B(TestLessThanOrEqual), R(arg0),
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),
+ /* 160 S> */ B(Ldar), R(arg1),
+ /* 166 E> */ B(TestGreaterThanOrEqual), R(arg0),
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),
+ /* 188 S> */ B(Ldar), R(arg1),
+ /* 194 E> */ B(TestIn), R(arg0),
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),
+ /* 216 S> */ B(Ldar), R(arg1),
+ /* 222 E> */ B(TestInstanceOf), R(arg0),
B(JumpIfFalse), U8(5),
/* 238 S> */ B(LdaSmi), U8(1),
/* 262 S> */ B(Return),
@@ -749,7 +724,7 @@
bytecodes: [
/* 10 E> */ B(StackCheck),
/* 25 S> */ B(LdaZero),
- /* 25 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 30 S> */ B(JumpIfToBooleanFalse), U8(5),
/* 43 S> */ B(LdaSmi), U8(20),
/* 85 S> */ B(Return),
diff --git a/test/cctest/interpreter/bytecode_expectations/IntegerConstants.golden b/test/cctest/interpreter/bytecode_expectations/IntegerConstants.golden
index f82e5f8..6ac81a6 100644
--- a/test/cctest/interpreter/bytecode_expectations/IntegerConstants.golden
+++ b/test/cctest/interpreter/bytecode_expectations/IntegerConstants.golden
@@ -34,7 +34,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(Wide), B(LdaSmi), U16(1234),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 48 S> */ B(Wide), B(LdaSmi), U16(5678),
/* 61 S> */ B(Return),
]
@@ -53,7 +53,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(Wide), B(LdaSmi), U16(1234),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 48 S> */ B(Wide), B(LdaSmi), U16(1234),
/* 61 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/JumpsRequiringConstantWideOperands.golden b/test/cctest/interpreter/bytecode_expectations/JumpsRequiringConstantWideOperands.golden
index 84810b1..3bf0a4f 100644
--- a/test/cctest/interpreter/bytecode_expectations/JumpsRequiringConstantWideOperands.golden
+++ b/test/cctest/interpreter/bytecode_expectations/JumpsRequiringConstantWideOperands.golden
@@ -329,659 +329,653 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 1422
+bytecode array length: 1410
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 55 S> */ B(LdaConstant), U8(1),
- /* 55 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 68 S> */ B(LdaConstant), U8(2),
- /* 68 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 81 S> */ B(LdaConstant), U8(3),
- /* 81 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 94 S> */ B(LdaConstant), U8(4),
- /* 94 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 107 S> */ B(LdaConstant), U8(5),
- /* 107 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 120 S> */ B(LdaConstant), U8(6),
- /* 120 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 133 S> */ B(LdaConstant), U8(7),
- /* 133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 146 S> */ B(LdaConstant), U8(8),
- /* 146 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 159 S> */ B(LdaConstant), U8(9),
- /* 159 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 172 S> */ B(LdaConstant), U8(10),
- /* 172 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 185 S> */ B(LdaConstant), U8(11),
- /* 185 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 198 S> */ B(LdaConstant), U8(12),
- /* 198 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 211 S> */ B(LdaConstant), U8(13),
- /* 211 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 224 S> */ B(LdaConstant), U8(14),
- /* 224 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 237 S> */ B(LdaConstant), U8(15),
- /* 237 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 250 S> */ B(LdaConstant), U8(16),
- /* 250 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 263 S> */ B(LdaConstant), U8(17),
- /* 263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 276 S> */ B(LdaConstant), U8(18),
- /* 276 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 289 S> */ B(LdaConstant), U8(19),
- /* 289 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 302 S> */ B(LdaConstant), U8(20),
- /* 302 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 315 S> */ B(LdaConstant), U8(21),
- /* 315 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 328 S> */ B(LdaConstant), U8(22),
- /* 328 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 341 S> */ B(LdaConstant), U8(23),
- /* 341 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 354 S> */ B(LdaConstant), U8(24),
- /* 354 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 367 S> */ B(LdaConstant), U8(25),
- /* 367 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 380 S> */ B(LdaConstant), U8(26),
- /* 380 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 393 S> */ B(LdaConstant), U8(27),
- /* 393 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 406 S> */ B(LdaConstant), U8(28),
- /* 406 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 419 S> */ B(LdaConstant), U8(29),
- /* 419 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 432 S> */ B(LdaConstant), U8(30),
- /* 432 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 445 S> */ B(LdaConstant), U8(31),
- /* 445 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 458 S> */ B(LdaConstant), U8(32),
- /* 458 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 471 S> */ B(LdaConstant), U8(33),
- /* 471 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 484 S> */ B(LdaConstant), U8(34),
- /* 484 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 497 S> */ B(LdaConstant), U8(35),
- /* 497 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 510 S> */ B(LdaConstant), U8(36),
- /* 510 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 523 S> */ B(LdaConstant), U8(37),
- /* 523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 536 S> */ B(LdaConstant), U8(38),
- /* 536 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 549 S> */ B(LdaConstant), U8(39),
- /* 549 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 562 S> */ B(LdaConstant), U8(40),
- /* 562 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 575 S> */ B(LdaConstant), U8(41),
- /* 575 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 588 S> */ B(LdaConstant), U8(42),
- /* 588 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 601 S> */ B(LdaConstant), U8(43),
- /* 601 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 614 S> */ B(LdaConstant), U8(44),
- /* 614 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 627 S> */ B(LdaConstant), U8(45),
- /* 627 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 640 S> */ B(LdaConstant), U8(46),
- /* 640 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 653 S> */ B(LdaConstant), U8(47),
- /* 653 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 666 S> */ B(LdaConstant), U8(48),
- /* 666 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 679 S> */ B(LdaConstant), U8(49),
- /* 679 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 692 S> */ B(LdaConstant), U8(50),
- /* 692 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 705 S> */ B(LdaConstant), U8(51),
- /* 705 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 718 S> */ B(LdaConstant), U8(52),
- /* 718 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 731 S> */ B(LdaConstant), U8(53),
- /* 731 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 744 S> */ B(LdaConstant), U8(54),
- /* 744 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 757 S> */ B(LdaConstant), U8(55),
- /* 757 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 770 S> */ B(LdaConstant), U8(56),
- /* 770 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 783 S> */ B(LdaConstant), U8(57),
- /* 783 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 796 S> */ B(LdaConstant), U8(58),
- /* 796 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 809 S> */ B(LdaConstant), U8(59),
- /* 809 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 822 S> */ B(LdaConstant), U8(60),
- /* 822 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 835 S> */ B(LdaConstant), U8(61),
- /* 835 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 848 S> */ B(LdaConstant), U8(62),
- /* 848 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 861 S> */ B(LdaConstant), U8(63),
- /* 861 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 874 S> */ B(LdaConstant), U8(64),
- /* 874 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 887 S> */ B(LdaConstant), U8(65),
- /* 887 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 900 S> */ B(LdaConstant), U8(66),
- /* 900 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 913 S> */ B(LdaConstant), U8(67),
- /* 913 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 926 S> */ B(LdaConstant), U8(68),
- /* 926 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 939 S> */ B(LdaConstant), U8(69),
- /* 939 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 952 S> */ B(LdaConstant), U8(70),
- /* 952 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 965 S> */ B(LdaConstant), U8(71),
- /* 965 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 978 S> */ B(LdaConstant), U8(72),
- /* 978 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 991 S> */ B(LdaConstant), U8(73),
- /* 991 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1004 S> */ B(LdaConstant), U8(74),
- /* 1004 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1017 S> */ B(LdaConstant), U8(75),
- /* 1017 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1030 S> */ B(LdaConstant), U8(76),
- /* 1030 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1043 S> */ B(LdaConstant), U8(77),
- /* 1043 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1056 S> */ B(LdaConstant), U8(78),
- /* 1056 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1069 S> */ B(LdaConstant), U8(79),
- /* 1069 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1082 S> */ B(LdaConstant), U8(80),
- /* 1082 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1095 S> */ B(LdaConstant), U8(81),
- /* 1095 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1108 S> */ B(LdaConstant), U8(82),
- /* 1108 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1121 S> */ B(LdaConstant), U8(83),
- /* 1121 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1134 S> */ B(LdaConstant), U8(84),
- /* 1134 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1147 S> */ B(LdaConstant), U8(85),
- /* 1147 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1160 S> */ B(LdaConstant), U8(86),
- /* 1160 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1173 S> */ B(LdaConstant), U8(87),
- /* 1173 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1186 S> */ B(LdaConstant), U8(88),
- /* 1186 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1199 S> */ B(LdaConstant), U8(89),
- /* 1199 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1212 S> */ B(LdaConstant), U8(90),
- /* 1212 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1225 S> */ B(LdaConstant), U8(91),
- /* 1225 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1238 S> */ B(LdaConstant), U8(92),
- /* 1238 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1251 S> */ B(LdaConstant), U8(93),
- /* 1251 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1264 S> */ B(LdaConstant), U8(94),
- /* 1264 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1277 S> */ B(LdaConstant), U8(95),
- /* 1277 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1290 S> */ B(LdaConstant), U8(96),
- /* 1290 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1303 S> */ B(LdaConstant), U8(97),
- /* 1303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1316 S> */ B(LdaConstant), U8(98),
- /* 1316 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1329 S> */ B(LdaConstant), U8(99),
- /* 1329 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1342 S> */ B(LdaConstant), U8(100),
- /* 1342 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1355 S> */ B(LdaConstant), U8(101),
- /* 1355 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1368 S> */ B(LdaConstant), U8(102),
- /* 1368 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1381 S> */ B(LdaConstant), U8(103),
- /* 1381 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1394 S> */ B(LdaConstant), U8(104),
- /* 1394 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1407 S> */ B(LdaConstant), U8(105),
- /* 1407 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1420 S> */ B(LdaConstant), U8(106),
- /* 1420 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1433 S> */ B(LdaConstant), U8(107),
- /* 1433 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1446 S> */ B(LdaConstant), U8(108),
- /* 1446 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1459 S> */ B(LdaConstant), U8(109),
- /* 1459 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1472 S> */ B(LdaConstant), U8(110),
- /* 1472 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1485 S> */ B(LdaConstant), U8(111),
- /* 1485 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1498 S> */ B(LdaConstant), U8(112),
- /* 1498 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1511 S> */ B(LdaConstant), U8(113),
- /* 1511 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1524 S> */ B(LdaConstant), U8(114),
- /* 1524 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1537 S> */ B(LdaConstant), U8(115),
- /* 1537 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1550 S> */ B(LdaConstant), U8(116),
- /* 1550 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1563 S> */ B(LdaConstant), U8(117),
- /* 1563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1576 S> */ B(LdaConstant), U8(118),
- /* 1576 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1589 S> */ B(LdaConstant), U8(119),
- /* 1589 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1602 S> */ B(LdaConstant), U8(120),
- /* 1602 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1615 S> */ B(LdaConstant), U8(121),
- /* 1615 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1628 S> */ B(LdaConstant), U8(122),
- /* 1628 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1641 S> */ B(LdaConstant), U8(123),
- /* 1641 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1654 S> */ B(LdaConstant), U8(124),
- /* 1654 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1667 S> */ B(LdaConstant), U8(125),
- /* 1667 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1680 S> */ B(LdaConstant), U8(126),
- /* 1680 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1693 S> */ B(LdaConstant), U8(127),
- /* 1693 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1706 S> */ B(LdaConstant), U8(128),
- /* 1706 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1719 S> */ B(LdaConstant), U8(129),
- /* 1719 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1732 S> */ B(LdaConstant), U8(130),
- /* 1732 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1745 S> */ B(LdaConstant), U8(131),
- /* 1745 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1758 S> */ B(LdaConstant), U8(132),
- /* 1758 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1771 S> */ B(LdaConstant), U8(133),
- /* 1771 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1784 S> */ B(LdaConstant), U8(134),
- /* 1784 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1797 S> */ B(LdaConstant), U8(135),
- /* 1797 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1810 S> */ B(LdaConstant), U8(136),
- /* 1810 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1823 S> */ B(LdaConstant), U8(137),
- /* 1823 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1836 S> */ B(LdaConstant), U8(138),
- /* 1836 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1849 S> */ B(LdaConstant), U8(139),
- /* 1849 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1862 S> */ B(LdaConstant), U8(140),
- /* 1862 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1875 S> */ B(LdaConstant), U8(141),
- /* 1875 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1888 S> */ B(LdaConstant), U8(142),
- /* 1888 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1901 S> */ B(LdaConstant), U8(143),
- /* 1901 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1914 S> */ B(LdaConstant), U8(144),
- /* 1914 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1927 S> */ B(LdaConstant), U8(145),
- /* 1927 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1940 S> */ B(LdaConstant), U8(146),
- /* 1940 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1953 S> */ B(LdaConstant), U8(147),
- /* 1953 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1966 S> */ B(LdaConstant), U8(148),
- /* 1966 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1979 S> */ B(LdaConstant), U8(149),
- /* 1979 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1992 S> */ B(LdaConstant), U8(150),
- /* 1992 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2005 S> */ B(LdaConstant), U8(151),
- /* 2005 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2018 S> */ B(LdaConstant), U8(152),
- /* 2018 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2031 S> */ B(LdaConstant), U8(153),
- /* 2031 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2044 S> */ B(LdaConstant), U8(154),
- /* 2044 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2057 S> */ B(LdaConstant), U8(155),
- /* 2057 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2070 S> */ B(LdaConstant), U8(156),
- /* 2070 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2083 S> */ B(LdaConstant), U8(157),
- /* 2083 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2096 S> */ B(LdaConstant), U8(158),
- /* 2096 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2109 S> */ B(LdaConstant), U8(159),
- /* 2109 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2122 S> */ B(LdaConstant), U8(160),
- /* 2122 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2135 S> */ B(LdaConstant), U8(161),
- /* 2135 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2148 S> */ B(LdaConstant), U8(162),
- /* 2148 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2161 S> */ B(LdaConstant), U8(163),
- /* 2161 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2174 S> */ B(LdaConstant), U8(164),
- /* 2174 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2187 S> */ B(LdaConstant), U8(165),
- /* 2187 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2200 S> */ B(LdaConstant), U8(166),
- /* 2200 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2213 S> */ B(LdaConstant), U8(167),
- /* 2213 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2226 S> */ B(LdaConstant), U8(168),
- /* 2226 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2239 S> */ B(LdaConstant), U8(169),
- /* 2239 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2252 S> */ B(LdaConstant), U8(170),
- /* 2252 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2265 S> */ B(LdaConstant), U8(171),
- /* 2265 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2278 S> */ B(LdaConstant), U8(172),
- /* 2278 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2291 S> */ B(LdaConstant), U8(173),
- /* 2291 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2304 S> */ B(LdaConstant), U8(174),
- /* 2304 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2317 S> */ B(LdaConstant), U8(175),
- /* 2317 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2330 S> */ B(LdaConstant), U8(176),
- /* 2330 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2343 S> */ B(LdaConstant), U8(177),
- /* 2343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2356 S> */ B(LdaConstant), U8(178),
- /* 2356 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2369 S> */ B(LdaConstant), U8(179),
- /* 2369 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2382 S> */ B(LdaConstant), U8(180),
- /* 2382 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2395 S> */ B(LdaConstant), U8(181),
- /* 2395 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2408 S> */ B(LdaConstant), U8(182),
- /* 2408 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2421 S> */ B(LdaConstant), U8(183),
- /* 2421 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2434 S> */ B(LdaConstant), U8(184),
- /* 2434 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2447 S> */ B(LdaConstant), U8(185),
- /* 2447 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2460 S> */ B(LdaConstant), U8(186),
- /* 2460 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2473 S> */ B(LdaConstant), U8(187),
- /* 2473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2486 S> */ B(LdaConstant), U8(188),
- /* 2486 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2499 S> */ B(LdaConstant), U8(189),
- /* 2499 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2512 S> */ B(LdaConstant), U8(190),
- /* 2512 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2525 S> */ B(LdaConstant), U8(191),
- /* 2525 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2538 S> */ B(LdaConstant), U8(192),
- /* 2538 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2551 S> */ B(LdaConstant), U8(193),
- /* 2551 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2564 S> */ B(LdaConstant), U8(194),
- /* 2564 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2577 S> */ B(LdaConstant), U8(195),
- /* 2577 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2590 S> */ B(LdaConstant), U8(196),
- /* 2590 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2603 S> */ B(LdaConstant), U8(197),
- /* 2603 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2616 S> */ B(LdaConstant), U8(198),
- /* 2616 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2629 S> */ B(LdaConstant), U8(199),
- /* 2629 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2642 S> */ B(LdaConstant), U8(200),
- /* 2642 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2655 S> */ B(LdaConstant), U8(201),
- /* 2655 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2668 S> */ B(LdaConstant), U8(202),
- /* 2668 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2681 S> */ B(LdaConstant), U8(203),
- /* 2681 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2694 S> */ B(LdaConstant), U8(204),
- /* 2694 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2707 S> */ B(LdaConstant), U8(205),
- /* 2707 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2720 S> */ B(LdaConstant), U8(206),
- /* 2720 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2733 S> */ B(LdaConstant), U8(207),
- /* 2733 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2746 S> */ B(LdaConstant), U8(208),
- /* 2746 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2759 S> */ B(LdaConstant), U8(209),
- /* 2759 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2772 S> */ B(LdaConstant), U8(210),
- /* 2772 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2785 S> */ B(LdaConstant), U8(211),
- /* 2785 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2798 S> */ B(LdaConstant), U8(212),
- /* 2798 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2811 S> */ B(LdaConstant), U8(213),
- /* 2811 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2824 S> */ B(LdaConstant), U8(214),
- /* 2824 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2837 S> */ B(LdaConstant), U8(215),
- /* 2837 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2850 S> */ B(LdaConstant), U8(216),
- /* 2850 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2863 S> */ B(LdaConstant), U8(217),
- /* 2863 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2876 S> */ B(LdaConstant), U8(218),
- /* 2876 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2889 S> */ B(LdaConstant), U8(219),
- /* 2889 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2902 S> */ B(LdaConstant), U8(220),
- /* 2902 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2915 S> */ B(LdaConstant), U8(221),
- /* 2915 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2928 S> */ B(LdaConstant), U8(222),
- /* 2928 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2941 S> */ B(LdaConstant), U8(223),
- /* 2941 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2954 S> */ B(LdaConstant), U8(224),
- /* 2954 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2967 S> */ B(LdaConstant), U8(225),
- /* 2967 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2980 S> */ B(LdaConstant), U8(226),
- /* 2980 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2993 S> */ B(LdaConstant), U8(227),
- /* 2993 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3006 S> */ B(LdaConstant), U8(228),
- /* 3006 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3019 S> */ B(LdaConstant), U8(229),
- /* 3019 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3032 S> */ B(LdaConstant), U8(230),
- /* 3032 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3045 S> */ B(LdaConstant), U8(231),
- /* 3045 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3058 S> */ B(LdaConstant), U8(232),
- /* 3058 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3071 S> */ B(LdaConstant), U8(233),
- /* 3071 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3084 S> */ B(LdaConstant), U8(234),
- /* 3084 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3097 S> */ B(LdaConstant), U8(235),
- /* 3097 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3110 S> */ B(LdaConstant), U8(236),
- /* 3110 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3123 S> */ B(LdaConstant), U8(237),
- /* 3123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3136 S> */ B(LdaConstant), U8(238),
- /* 3136 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3149 S> */ B(LdaConstant), U8(239),
- /* 3149 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3162 S> */ B(LdaConstant), U8(240),
- /* 3162 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3175 S> */ B(LdaConstant), U8(241),
- /* 3175 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3188 S> */ B(LdaConstant), U8(242),
- /* 3188 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3201 S> */ B(LdaConstant), U8(243),
- /* 3201 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3214 S> */ B(LdaConstant), U8(244),
- /* 3214 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3227 S> */ B(LdaConstant), U8(245),
- /* 3227 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3240 S> */ B(LdaConstant), U8(246),
- /* 3240 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3253 S> */ B(LdaConstant), U8(247),
- /* 3253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3266 S> */ B(LdaConstant), U8(248),
- /* 3266 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3279 S> */ B(LdaConstant), U8(249),
- /* 3279 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3292 S> */ B(LdaConstant), U8(250),
- /* 3292 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3305 S> */ B(LdaConstant), U8(251),
- /* 3305 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3318 S> */ B(LdaConstant), U8(252),
- /* 3318 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3331 S> */ B(LdaConstant), U8(253),
- /* 3331 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3344 S> */ B(LdaConstant), U8(254),
- /* 3344 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3357 S> */ B(LdaConstant), U8(255),
- /* 3357 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3370 S> */ B(Wide), B(LdaConstant), U16(256),
- /* 3370 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3383 S> */ B(Wide), B(LdaConstant), U16(257),
- /* 3383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3396 S> */ B(Wide), B(LdaConstant), U16(258),
- /* 3396 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3409 S> */ B(Wide), B(LdaConstant), U16(259),
- /* 3409 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3422 S> */ B(Wide), B(LdaConstant), U16(260),
- /* 3422 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3435 S> */ B(Wide), B(LdaConstant), U16(261),
- /* 3435 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3448 S> */ B(Wide), B(LdaConstant), U16(262),
- /* 3448 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3461 S> */ B(Wide), B(LdaConstant), U16(263),
- /* 3461 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3474 S> */ B(Wide), B(LdaConstant), U16(264),
- /* 3474 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3487 S> */ B(Wide), B(LdaConstant), U16(265),
- /* 3487 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3500 S> */ B(Wide), B(LdaConstant), U16(266),
- /* 3500 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3513 S> */ B(Wide), B(LdaConstant), U16(267),
- /* 3513 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3526 S> */ B(Wide), B(LdaConstant), U16(268),
- /* 3526 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3539 S> */ B(Wide), B(LdaConstant), U16(269),
- /* 3539 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3552 S> */ B(Wide), B(LdaConstant), U16(270),
- /* 3552 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3565 S> */ B(Wide), B(LdaConstant), U16(271),
- /* 3565 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3578 S> */ B(Wide), B(LdaConstant), U16(272),
- /* 3578 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3591 S> */ B(Wide), B(LdaConstant), U16(273),
- /* 3591 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3604 S> */ B(Wide), B(LdaConstant), U16(274),
- /* 3604 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3617 S> */ B(Wide), B(LdaConstant), U16(275),
- /* 3617 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3630 S> */ B(Wide), B(LdaConstant), U16(276),
- /* 3630 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3643 S> */ B(Wide), B(LdaConstant), U16(277),
- /* 3643 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3656 S> */ B(Wide), B(LdaConstant), U16(278),
- /* 3656 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3669 S> */ B(Wide), B(LdaConstant), U16(279),
- /* 3669 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3682 S> */ B(Wide), B(LdaConstant), U16(280),
- /* 3682 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3695 S> */ B(Wide), B(LdaConstant), U16(281),
- /* 3695 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3708 S> */ B(Wide), B(LdaConstant), U16(282),
- /* 3708 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3721 S> */ B(Wide), B(LdaConstant), U16(283),
- /* 3721 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3734 S> */ B(Wide), B(LdaConstant), U16(284),
- /* 3734 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3747 S> */ B(Wide), B(LdaConstant), U16(285),
- /* 3747 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3760 S> */ B(Wide), B(LdaConstant), U16(286),
- /* 3760 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3773 S> */ B(Wide), B(LdaConstant), U16(287),
- /* 3773 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3786 S> */ B(Wide), B(LdaConstant), U16(288),
- /* 3786 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3799 S> */ B(Wide), B(LdaConstant), U16(289),
- /* 3799 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3812 S> */ B(Wide), B(LdaConstant), U16(290),
- /* 3812 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3825 S> */ B(Wide), B(LdaConstant), U16(291),
- /* 3825 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3838 S> */ B(Wide), B(LdaConstant), U16(292),
- /* 3838 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3851 S> */ B(Wide), B(LdaConstant), U16(293),
- /* 3851 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3864 S> */ B(Wide), B(LdaConstant), U16(294),
- /* 3864 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3877 S> */ B(Wide), B(LdaConstant), U16(295),
- /* 3877 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3890 S> */ B(Wide), B(LdaConstant), U16(296),
- /* 3890 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3903 S> */ B(Wide), B(LdaConstant), U16(297),
- /* 3903 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3916 S> */ B(Wide), B(LdaConstant), U16(298),
- /* 3916 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3929 S> */ B(Wide), B(LdaConstant), U16(299),
- /* 3929 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3942 S> */ B(Wide), B(LdaConstant), U16(300),
- /* 3942 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3955 S> */ B(Wide), B(LdaConstant), U16(301),
- /* 3955 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3968 S> */ B(Wide), B(LdaConstant), U16(302),
- /* 3968 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3981 S> */ B(Wide), B(LdaConstant), U16(303),
- /* 3981 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3994 S> */ B(Wide), B(LdaConstant), U16(304),
- /* 3994 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 4007 S> */ B(Wide), B(LdaConstant), U16(305),
- /* 4007 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 4020 S> */ B(Wide), B(LdaConstant), U16(306),
- /* 4020 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 4033 S> */ B(Wide), B(LdaConstant), U16(307),
- /* 4033 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 4046 S> */ B(Wide), B(LdaConstant), U16(308),
- /* 4046 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 4059 S> */ B(Wide), B(LdaConstant), U16(309),
- /* 4059 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 4072 S> */ B(Wide), B(LdaConstant), U16(310),
- /* 4072 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 4085 S> */ B(Wide), B(LdaConstant), U16(311),
- /* 4085 E> */ B(Star), R(0),
+ 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),
+ B(Star), R(1),
+ /* 4108 S> */ B(LdaSmi), U8(3),
+ /* 4108 E> */ B(TestLessThan), R(1),
+ B(Wide), B(JumpIfFalse), U16(38),
/* 4090 E> */ B(StackCheck),
- /* 4122 S> */ B(Ldar), R(1),
- B(Star), R(2),
- B(LdaSmi), U8(1),
- /* 4128 E> */ B(TestEqual), R(2),
+ /* 4122 S> */ B(LdaSmi), U8(1),
+ /* 4128 E> */ B(TestEqual), R(1),
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),
+ /* 4134 S> */ B(Wide), B(Jump), U16(15),
+ /* 4146 S> */ B(LdaSmi), U8(2),
+ /* 4152 E> */ B(TestEqual), R(1),
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),
+ B(Star), R(1),
+ B(Jump), U8(-41),
/* 4167 S> */ B(LdaSmi), U8(3),
/* 4177 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/LetVariable.golden b/test/cctest/interpreter/bytecode_expectations/LetVariable.golden
index 3ac793a..e54769c 100644
--- a/test/cctest/interpreter/bytecode_expectations/LetVariable.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LetVariable.golden
@@ -19,7 +19,7 @@
B(Star), R(0),
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(10),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
B(LdaUndefined),
/* 46 S> */ B(Return),
]
@@ -40,7 +40,7 @@
B(Star), R(0),
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(10),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 46 S> */ B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(0),
B(Star), R(1),
@@ -59,21 +59,21 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 27
+bytecode array length: 28
bytecodes: [
B(LdaTheHole),
B(Star), R(0),
/* 30 E> */ B(StackCheck),
/* 45 S> */ B(LdaSmi), U8(20),
- /* 45 E> */ B(Star), R(1),
+ 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),
+ /* 45 E> */ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ B(Mov), R(1), R(0),
+ B(Ldar), R(0),
+ B(LdaUndefined),
/* 52 S> */ B(Return),
]
constant pool: [
@@ -88,22 +88,21 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 31
+bytecode array length: 30
bytecodes: [
B(LdaTheHole),
B(Star), R(0),
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(10),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 46 S> */ B(LdaSmi), U8(20),
- /* 48 E> */ B(Star), R(1),
+ 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),
+ /* 48 E> */ B(CallRuntime), U16(Runtime::kThrowReferenceError), R(2), U8(1),
+ B(Mov), R(1), R(0),
B(LdaUndefined),
/* 54 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/LetVariableContextSlot.golden b/test/cctest/interpreter/bytecode_expectations/LetVariableContextSlot.golden
index 591fe88..4725033 100644
--- a/test/cctest/interpreter/bytecode_expectations/LetVariableContextSlot.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LetVariableContextSlot.golden
@@ -80,8 +80,8 @@
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(Star), R(2),
+ /* 45 E> */ B(LdaContextSlot), R(context), U8(4),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(1),
B(Star), R(3),
@@ -117,8 +117,8 @@
/* 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(Star), R(2),
+ /* 48 E> */ B(LdaContextSlot), R(context), U8(4),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(1),
B(Star), R(3),
diff --git a/test/cctest/interpreter/bytecode_expectations/LoadGlobal.golden b/test/cctest/interpreter/bytecode_expectations/LoadGlobal.golden
index 7fb831b..dd9f714 100644
--- a/test/cctest/interpreter/bytecode_expectations/LoadGlobal.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LoadGlobal.golden
@@ -16,14 +16,13 @@
"
frame size: 0
parameter count: 1
-bytecode array length: 5
+bytecode array length: 4
bytecodes: [
/* 21 E> */ B(StackCheck),
- /* 26 S> */ B(LdaGlobal), U8(0), U8(1),
+ /* 26 S> */ B(LdaGlobal), U8(1),
/* 36 S> */ B(Return),
]
constant pool: [
- "a",
]
handlers: [
]
@@ -36,14 +35,13 @@
"
frame size: 0
parameter count: 1
-bytecode array length: 5
+bytecode array length: 4
bytecodes: [
/* 27 E> */ B(StackCheck),
- /* 32 S> */ B(LdaGlobal), U8(0), U8(1),
+ /* 32 S> */ B(LdaGlobal), U8(1),
/* 42 S> */ B(Return),
]
constant pool: [
- "t",
]
handlers: [
]
@@ -56,14 +54,13 @@
"
frame size: 0
parameter count: 1
-bytecode array length: 5
+bytecode array length: 4
bytecodes: [
/* 17 E> */ B(StackCheck),
- /* 22 S> */ B(LdaGlobal), U8(0), U8(1),
+ /* 22 S> */ B(LdaGlobal), U8(1),
/* 32 S> */ B(Return),
]
constant pool: [
- "a",
]
handlers: [
]
@@ -204,401 +201,272 @@
}
f({name: 1});
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 1032
+bytecode array length: 646
bytecodes: [
/* 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),
+ /* 25 S> */ B(Nop),
+ /* 26 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(1),
+ /* 35 S> */ B(Nop),
+ /* 36 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(3),
+ /* 45 S> */ B(Nop),
+ /* 46 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(5),
+ /* 55 S> */ B(Nop),
+ /* 56 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(7),
+ /* 65 S> */ B(Nop),
+ /* 66 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(9),
+ /* 75 S> */ B(Nop),
+ /* 76 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(11),
+ /* 85 S> */ B(Nop),
+ /* 86 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(13),
+ /* 95 S> */ B(Nop),
+ /* 96 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(15),
+ /* 105 S> */ B(Nop),
+ /* 106 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(17),
+ /* 115 S> */ B(Nop),
+ /* 116 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(19),
+ /* 125 S> */ B(Nop),
+ /* 126 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(21),
+ /* 135 S> */ B(Nop),
+ /* 136 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(23),
+ /* 145 S> */ B(Nop),
+ /* 146 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(25),
+ /* 155 S> */ B(Nop),
+ /* 156 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(27),
+ /* 165 S> */ B(Nop),
+ /* 166 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(29),
+ /* 175 S> */ B(Nop),
+ /* 176 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(31),
+ /* 185 S> */ B(Nop),
+ /* 186 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(33),
+ /* 195 S> */ B(Nop),
+ /* 196 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(35),
+ /* 205 S> */ B(Nop),
+ /* 206 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(37),
+ /* 215 S> */ B(Nop),
+ /* 216 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(39),
+ /* 225 S> */ B(Nop),
+ /* 226 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(41),
+ /* 235 S> */ B(Nop),
+ /* 236 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(43),
+ /* 245 S> */ B(Nop),
+ /* 246 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(45),
+ /* 255 S> */ B(Nop),
+ /* 256 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(47),
+ /* 265 S> */ B(Nop),
+ /* 266 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(49),
+ /* 275 S> */ B(Nop),
+ /* 276 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(51),
+ /* 285 S> */ B(Nop),
+ /* 286 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(53),
+ /* 295 S> */ B(Nop),
+ /* 296 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(55),
+ /* 305 S> */ B(Nop),
+ /* 306 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(57),
+ /* 315 S> */ B(Nop),
+ /* 316 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(59),
+ /* 325 S> */ B(Nop),
+ /* 326 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(61),
+ /* 335 S> */ B(Nop),
+ /* 336 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(63),
+ /* 345 S> */ B(Nop),
+ /* 346 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(65),
+ /* 355 S> */ B(Nop),
+ /* 356 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(67),
+ /* 365 S> */ B(Nop),
+ /* 366 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(69),
+ /* 375 S> */ B(Nop),
+ /* 376 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(71),
+ /* 385 S> */ B(Nop),
+ /* 386 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(73),
+ /* 395 S> */ B(Nop),
+ /* 396 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(75),
+ /* 405 S> */ B(Nop),
+ /* 406 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(77),
+ /* 415 S> */ B(Nop),
+ /* 416 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(79),
+ /* 425 S> */ B(Nop),
+ /* 426 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(81),
+ /* 435 S> */ B(Nop),
+ /* 436 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(83),
+ /* 445 S> */ B(Nop),
+ /* 446 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(85),
+ /* 455 S> */ B(Nop),
+ /* 456 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(87),
+ /* 465 S> */ B(Nop),
+ /* 466 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(89),
+ /* 475 S> */ B(Nop),
+ /* 476 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(91),
+ /* 485 S> */ B(Nop),
+ /* 486 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(93),
+ /* 495 S> */ B(Nop),
+ /* 496 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(95),
+ /* 505 S> */ B(Nop),
+ /* 506 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(97),
+ /* 515 S> */ B(Nop),
+ /* 516 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(99),
+ /* 525 S> */ B(Nop),
+ /* 526 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(101),
+ /* 535 S> */ B(Nop),
+ /* 536 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(103),
+ /* 545 S> */ B(Nop),
+ /* 546 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(105),
+ /* 555 S> */ B(Nop),
+ /* 556 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(107),
+ /* 565 S> */ B(Nop),
+ /* 566 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(109),
+ /* 575 S> */ B(Nop),
+ /* 576 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(111),
+ /* 585 S> */ B(Nop),
+ /* 586 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(113),
+ /* 595 S> */ B(Nop),
+ /* 596 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(115),
+ /* 605 S> */ B(Nop),
+ /* 606 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(117),
+ /* 615 S> */ B(Nop),
+ /* 616 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(119),
+ /* 625 S> */ B(Nop),
+ /* 626 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(121),
+ /* 635 S> */ B(Nop),
+ /* 636 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(123),
+ /* 645 S> */ B(Nop),
+ /* 646 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(125),
+ /* 655 S> */ B(Nop),
+ /* 656 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(127),
+ /* 665 S> */ B(Nop),
+ /* 666 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(129),
+ /* 675 S> */ B(Nop),
+ /* 676 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(131),
+ /* 685 S> */ B(Nop),
+ /* 686 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(133),
+ /* 695 S> */ B(Nop),
+ /* 696 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(135),
+ /* 705 S> */ B(Nop),
+ /* 706 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(137),
+ /* 715 S> */ B(Nop),
+ /* 716 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(139),
+ /* 725 S> */ B(Nop),
+ /* 726 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(141),
+ /* 735 S> */ B(Nop),
+ /* 736 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(143),
+ /* 745 S> */ B(Nop),
+ /* 746 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(145),
+ /* 755 S> */ B(Nop),
+ /* 756 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(147),
+ /* 765 S> */ B(Nop),
+ /* 766 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(149),
+ /* 775 S> */ B(Nop),
+ /* 776 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(151),
+ /* 785 S> */ B(Nop),
+ /* 786 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(153),
+ /* 795 S> */ B(Nop),
+ /* 796 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(155),
+ /* 805 S> */ B(Nop),
+ /* 806 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(157),
+ /* 815 S> */ B(Nop),
+ /* 816 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(159),
+ /* 825 S> */ B(Nop),
+ /* 826 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(161),
+ /* 835 S> */ B(Nop),
+ /* 836 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(163),
+ /* 845 S> */ B(Nop),
+ /* 846 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(165),
+ /* 855 S> */ B(Nop),
+ /* 856 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(167),
+ /* 865 S> */ B(Nop),
+ /* 866 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(169),
+ /* 875 S> */ B(Nop),
+ /* 876 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(171),
+ /* 885 S> */ B(Nop),
+ /* 886 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(173),
+ /* 895 S> */ B(Nop),
+ /* 896 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(175),
+ /* 905 S> */ B(Nop),
+ /* 906 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(177),
+ /* 915 S> */ B(Nop),
+ /* 916 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(179),
+ /* 925 S> */ B(Nop),
+ /* 926 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(181),
+ /* 935 S> */ B(Nop),
+ /* 936 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(183),
+ /* 945 S> */ B(Nop),
+ /* 946 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(185),
+ /* 955 S> */ B(Nop),
+ /* 956 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(187),
+ /* 965 S> */ B(Nop),
+ /* 966 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(189),
+ /* 975 S> */ B(Nop),
+ /* 976 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(191),
+ /* 985 S> */ B(Nop),
+ /* 986 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(193),
+ /* 995 S> */ B(Nop),
+ /* 996 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(195),
+ /* 1005 S> */ B(Nop),
+ /* 1006 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(197),
+ /* 1015 S> */ B(Nop),
+ /* 1016 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(199),
+ /* 1025 S> */ B(Nop),
+ /* 1026 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(201),
+ /* 1035 S> */ B(Nop),
+ /* 1036 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(203),
+ /* 1045 S> */ B(Nop),
+ /* 1046 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(205),
+ /* 1055 S> */ B(Nop),
+ /* 1056 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(207),
+ /* 1065 S> */ B(Nop),
+ /* 1066 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(209),
+ /* 1075 S> */ B(Nop),
+ /* 1076 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(211),
+ /* 1085 S> */ B(Nop),
+ /* 1086 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(213),
+ /* 1095 S> */ B(Nop),
+ /* 1096 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(215),
+ /* 1105 S> */ B(Nop),
+ /* 1106 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(217),
+ /* 1115 S> */ B(Nop),
+ /* 1116 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(219),
+ /* 1125 S> */ B(Nop),
+ /* 1126 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(221),
+ /* 1135 S> */ B(Nop),
+ /* 1136 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(223),
+ /* 1145 S> */ B(Nop),
+ /* 1146 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(225),
+ /* 1155 S> */ B(Nop),
+ /* 1156 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(227),
+ /* 1165 S> */ B(Nop),
+ /* 1166 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(229),
+ /* 1175 S> */ B(Nop),
+ /* 1176 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(231),
+ /* 1185 S> */ B(Nop),
+ /* 1186 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(233),
+ /* 1195 S> */ B(Nop),
+ /* 1196 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(235),
+ /* 1205 S> */ B(Nop),
+ /* 1206 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(237),
+ /* 1215 S> */ B(Nop),
+ /* 1216 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(239),
+ /* 1225 S> */ B(Nop),
+ /* 1226 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(241),
+ /* 1235 S> */ B(Nop),
+ /* 1236 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(243),
+ /* 1245 S> */ B(Nop),
+ /* 1246 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(245),
+ /* 1255 S> */ B(Nop),
+ /* 1256 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(247),
+ /* 1265 S> */ B(Nop),
+ /* 1266 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(249),
+ /* 1275 S> */ B(Nop),
+ /* 1276 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(251),
+ /* 1285 S> */ B(Nop),
+ /* 1286 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(253),
+ /* 1295 S> */ B(Nop),
+ /* 1296 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(255),
+ /* 1305 S> */ B(Wide), B(LdaGlobal), U16(257),
/* 1315 S> */ B(Return),
]
constant pool: [
"name",
- "a",
]
handlers: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/LogicalExpressions.golden b/test/cctest/interpreter/bytecode_expectations/LogicalExpressions.golden
index fed8367..b8c8c5f 100644
--- a/test/cctest/interpreter/bytecode_expectations/LogicalExpressions.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LogicalExpressions.golden
@@ -17,7 +17,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(JumpIfToBooleanTrue), U8(4),
B(LdaSmi), U8(3),
/* 60 S> */ B(Return),
@@ -31,16 +31,15 @@
snippet: "
var x = 0; return (x == 1) || 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 15
+bytecode array length: 13
bytecodes: [
/* 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(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(1),
+ /* 55 E> */ B(TestEqual), R(0),
B(JumpIfTrue), U8(4),
B(LdaSmi), U8(3),
/* 67 S> */ B(Return),
@@ -60,7 +59,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(JumpIfToBooleanFalse), U8(4),
B(LdaSmi), U8(3),
/* 60 S> */ B(Return),
@@ -74,16 +73,15 @@
snippet: "
var x = 0; return (x == 0) && 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 14
+bytecode array length: 12
bytecodes: [
/* 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(Star), R(0),
+ /* 45 S> */ B(LdaZero),
+ /* 55 E> */ B(TestEqual), R(0),
B(JumpIfFalse), U8(4),
B(LdaSmi), U8(3),
/* 67 S> */ B(Return),
@@ -103,7 +101,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(JumpIfToBooleanTrue), U8(4),
B(LdaSmi), U8(3),
/* 68 S> */ B(Return),
@@ -123,15 +121,15 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(2),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 49 S> */ B(LdaSmi), U8(3),
- /* 49 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 56 S> */ B(LdaSmi), U8(4),
- /* 56 E> */ B(Star), R(2),
+ 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(5),
+ B(Star), R(2),
B(LdaSmi), U8(3),
/* 95 S> */ B(Return),
]
@@ -182,141 +180,141 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 53 S> */ B(LdaSmi), U8(2),
- /* 53 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 60 S> */ B(LdaSmi), U8(3),
- /* 60 E> */ B(Star), R(2),
+ 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(Star), R(1),
B(LdaSmi), U8(2),
- /* 88 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 98 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 105 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 115 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 122 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 132 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 139 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 149 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 156 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 166 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 173 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 183 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 190 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 200 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 207 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 217 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 224 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 234 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 241 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 251 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 258 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 268 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 275 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 285 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 292 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 302 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 309 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 319 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 326 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 336 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 343 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 353 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 360 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 370 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 377 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 387 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 394 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 404 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 411 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 421 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 428 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 438 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 445 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 455 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 462 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 472 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 479 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 489 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 496 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 506 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 513 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 523 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 530 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 540 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 547 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 557 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 564 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 574 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 581 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 591 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 598 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 608 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 615 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(3),
/* 624 S> */ B(Return),
]
@@ -368,141 +366,141 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 53 S> */ B(LdaSmi), U8(2),
- /* 53 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 60 S> */ B(LdaSmi), U8(3),
- /* 60 E> */ B(Star), R(2),
+ 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(Star), R(1),
B(LdaSmi), U8(2),
- /* 88 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 98 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 105 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 115 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 122 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 132 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 139 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 149 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 156 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 166 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 173 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 183 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 190 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 200 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 207 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 217 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 224 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 234 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 241 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 251 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 258 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 268 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 275 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 285 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 292 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 302 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 309 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 319 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 326 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 336 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 343 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 353 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 360 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 370 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 377 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 387 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 394 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 404 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 411 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 421 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 428 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 438 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 445 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 455 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 462 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 472 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 479 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 489 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 496 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 506 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 513 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 523 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 530 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 540 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 547 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 557 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 564 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 574 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 581 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 591 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 598 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 608 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 615 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(3),
/* 624 S> */ B(Return),
]
@@ -548,150 +546,148 @@
a = 1, b = 2,
a = 1, b = 2, 3);
"
-frame size: 4
+frame size: 3
parameter count: 1
-bytecode array length: 282
+bytecode array length: 278
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 53 S> */ B(LdaSmi), U8(2),
- /* 53 E> */ B(Star), R(1),
+ 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(Star), R(2),
+ /* 63 S> */ B(LdaSmi), U8(3),
+ /* 73 E> */ B(TestGreaterThan), R(0),
B(JumpIfTrueConstant), U8(0),
B(LdaSmi), U8(1),
- /* 87 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 94 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 104 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 111 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 121 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 128 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 138 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 145 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 155 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 162 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 172 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 179 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 189 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 196 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 206 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 213 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 223 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 230 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 240 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 247 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 257 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 264 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 274 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 281 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 291 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 298 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 308 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 315 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 325 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 332 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 342 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 349 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 359 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 366 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 376 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 383 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 393 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 400 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 410 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 417 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 427 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 434 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 444 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 451 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 461 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 468 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 478 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 485 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 495 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 502 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 512 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 519 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 529 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 536 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 546 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 553 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 563 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 570 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 580 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 587 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 597 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 604 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 614 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 621 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(3),
/* 630 S> */ B(Return),
]
@@ -737,150 +733,148 @@
a = 1, b = 2,
a = 1, b = 2, 3);
"
-frame size: 4
+frame size: 3
parameter count: 1
-bytecode array length: 281
+bytecode array length: 277
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 53 S> */ B(LdaSmi), U8(2),
- /* 53 E> */ B(Star), R(1),
+ 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(Star), R(2),
+ /* 63 S> */ B(LdaSmi), U8(5),
+ /* 73 E> */ B(TestLessThan), R(0),
B(JumpIfFalseConstant), U8(0),
B(LdaSmi), U8(1),
- /* 87 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 94 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 104 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 111 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 121 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 128 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 138 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 145 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 155 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 162 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 172 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 179 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 189 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 196 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 206 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 213 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 223 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 230 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 240 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 247 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 257 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 264 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 274 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 281 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 291 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 298 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 308 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 315 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 325 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 332 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 342 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 349 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 359 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 366 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 376 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 383 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 393 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 400 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 410 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 417 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 427 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 434 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 444 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 451 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 461 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 468 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 478 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 485 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 495 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 502 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 512 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 519 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 529 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 536 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 546 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 553 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 563 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 570 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 580 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 587 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 597 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 604 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(1),
- /* 614 E> */ B(Star), R(1),
+ B(Star), R(1),
B(LdaSmi), U8(2),
- /* 621 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaSmi), U8(3),
/* 630 S> */ B(Return),
]
@@ -934,7 +928,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(JumpIfToBooleanFalse), U8(4),
B(LdaSmi), U8(3),
B(JumpIfToBooleanTrue), U8(3),
diff --git a/test/cctest/interpreter/bytecode_expectations/LookupSlot.golden b/test/cctest/interpreter/bytecode_expectations/LookupSlot.golden
index 99a78be..0ce9f01 100644
--- a/test/cctest/interpreter/bytecode_expectations/LookupSlot.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LookupSlot.golden
@@ -29,15 +29,15 @@
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(Mov), R(1), R(4),
+ B(Mov), R(3), R(5),
+ B(Mov), R(closure), R(6),
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),
@@ -74,15 +74,15 @@
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(Mov), R(1), R(4),
+ B(Mov), R(3), R(5),
+ B(Mov), R(closure), R(6),
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),
@@ -122,15 +122,15 @@
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(Mov), R(1), R(4),
+ B(Mov), R(3), R(5),
+ B(Mov), R(closure), R(6),
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),
diff --git a/test/cctest/interpreter/bytecode_expectations/LookupSlotWideInEval.golden b/test/cctest/interpreter/bytecode_expectations/LookupSlotWideInEval.golden
index 2d493bc..a668d62 100644
--- a/test/cctest/interpreter/bytecode_expectations/LookupSlotWideInEval.golden
+++ b/test/cctest/interpreter/bytecode_expectations/LookupSlotWideInEval.golden
@@ -283,517 +283,517 @@
bytecodes: [
/* 10 E> */ B(StackCheck),
/* 22 S> */ B(LdaConstant), U8(0),
- /* 22 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 34 S> */ B(LdaConstant), U8(1),
- /* 34 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 46 S> */ B(LdaConstant), U8(2),
- /* 46 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 58 S> */ B(LdaConstant), U8(3),
- /* 58 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 70 S> */ B(LdaConstant), U8(4),
- /* 70 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 82 S> */ B(LdaConstant), U8(5),
- /* 82 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 94 S> */ B(LdaConstant), U8(6),
- /* 94 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 106 S> */ B(LdaConstant), U8(7),
- /* 106 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 118 S> */ B(LdaConstant), U8(8),
- /* 118 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 130 S> */ B(LdaConstant), U8(9),
- /* 130 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 142 S> */ B(LdaConstant), U8(10),
- /* 142 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 154 S> */ B(LdaConstant), U8(11),
- /* 154 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 166 S> */ B(LdaConstant), U8(12),
- /* 166 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 178 S> */ B(LdaConstant), U8(13),
- /* 178 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 190 S> */ B(LdaConstant), U8(14),
- /* 190 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 202 S> */ B(LdaConstant), U8(15),
- /* 202 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 214 S> */ B(LdaConstant), U8(16),
- /* 214 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 226 S> */ B(LdaConstant), U8(17),
- /* 226 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 238 S> */ B(LdaConstant), U8(18),
- /* 238 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 250 S> */ B(LdaConstant), U8(19),
- /* 250 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 262 S> */ B(LdaConstant), U8(20),
- /* 262 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 274 S> */ B(LdaConstant), U8(21),
- /* 274 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 286 S> */ B(LdaConstant), U8(22),
- /* 286 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 298 S> */ B(LdaConstant), U8(23),
- /* 298 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 310 S> */ B(LdaConstant), U8(24),
- /* 310 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 322 S> */ B(LdaConstant), U8(25),
- /* 322 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 334 S> */ B(LdaConstant), U8(26),
- /* 334 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 346 S> */ B(LdaConstant), U8(27),
- /* 346 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 358 S> */ B(LdaConstant), U8(28),
- /* 358 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 370 S> */ B(LdaConstant), U8(29),
- /* 370 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 382 S> */ B(LdaConstant), U8(30),
- /* 382 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 394 S> */ B(LdaConstant), U8(31),
- /* 394 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 406 S> */ B(LdaConstant), U8(32),
- /* 406 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 418 S> */ B(LdaConstant), U8(33),
- /* 418 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 430 S> */ B(LdaConstant), U8(34),
- /* 430 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 442 S> */ B(LdaConstant), U8(35),
- /* 442 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 454 S> */ B(LdaConstant), U8(36),
- /* 454 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 466 S> */ B(LdaConstant), U8(37),
- /* 466 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 478 S> */ B(LdaConstant), U8(38),
- /* 478 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 490 S> */ B(LdaConstant), U8(39),
- /* 490 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 502 S> */ B(LdaConstant), U8(40),
- /* 502 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 514 S> */ B(LdaConstant), U8(41),
- /* 514 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 526 S> */ B(LdaConstant), U8(42),
- /* 526 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 538 S> */ B(LdaConstant), U8(43),
- /* 538 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 550 S> */ B(LdaConstant), U8(44),
- /* 550 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 562 S> */ B(LdaConstant), U8(45),
- /* 562 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 574 S> */ B(LdaConstant), U8(46),
- /* 574 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 586 S> */ B(LdaConstant), U8(47),
- /* 586 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 598 S> */ B(LdaConstant), U8(48),
- /* 598 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 610 S> */ B(LdaConstant), U8(49),
- /* 610 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 622 S> */ B(LdaConstant), U8(50),
- /* 622 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 634 S> */ B(LdaConstant), U8(51),
- /* 634 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 646 S> */ B(LdaConstant), U8(52),
- /* 646 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 658 S> */ B(LdaConstant), U8(53),
- /* 658 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 670 S> */ B(LdaConstant), U8(54),
- /* 670 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 682 S> */ B(LdaConstant), U8(55),
- /* 682 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 694 S> */ B(LdaConstant), U8(56),
- /* 694 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 706 S> */ B(LdaConstant), U8(57),
- /* 706 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 718 S> */ B(LdaConstant), U8(58),
- /* 718 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 730 S> */ B(LdaConstant), U8(59),
- /* 730 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 742 S> */ B(LdaConstant), U8(60),
- /* 742 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 754 S> */ B(LdaConstant), U8(61),
- /* 754 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 766 S> */ B(LdaConstant), U8(62),
- /* 766 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 778 S> */ B(LdaConstant), U8(63),
- /* 778 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 790 S> */ B(LdaConstant), U8(64),
- /* 790 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 802 S> */ B(LdaConstant), U8(65),
- /* 802 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 814 S> */ B(LdaConstant), U8(66),
- /* 814 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 826 S> */ B(LdaConstant), U8(67),
- /* 826 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 838 S> */ B(LdaConstant), U8(68),
- /* 838 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 850 S> */ B(LdaConstant), U8(69),
- /* 850 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 862 S> */ B(LdaConstant), U8(70),
- /* 862 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 874 S> */ B(LdaConstant), U8(71),
- /* 874 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 886 S> */ B(LdaConstant), U8(72),
- /* 886 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 898 S> */ B(LdaConstant), U8(73),
- /* 898 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 910 S> */ B(LdaConstant), U8(74),
- /* 910 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 922 S> */ B(LdaConstant), U8(75),
- /* 922 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 934 S> */ B(LdaConstant), U8(76),
- /* 934 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 946 S> */ B(LdaConstant), U8(77),
- /* 946 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 958 S> */ B(LdaConstant), U8(78),
- /* 958 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 970 S> */ B(LdaConstant), U8(79),
- /* 970 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 982 S> */ B(LdaConstant), U8(80),
- /* 982 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 994 S> */ B(LdaConstant), U8(81),
- /* 994 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1006 S> */ B(LdaConstant), U8(82),
- /* 1006 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1018 S> */ B(LdaConstant), U8(83),
- /* 1018 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1030 S> */ B(LdaConstant), U8(84),
- /* 1030 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1042 S> */ B(LdaConstant), U8(85),
- /* 1042 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1054 S> */ B(LdaConstant), U8(86),
- /* 1054 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1066 S> */ B(LdaConstant), U8(87),
- /* 1066 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1078 S> */ B(LdaConstant), U8(88),
- /* 1078 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1090 S> */ B(LdaConstant), U8(89),
- /* 1090 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1102 S> */ B(LdaConstant), U8(90),
- /* 1102 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1114 S> */ B(LdaConstant), U8(91),
- /* 1114 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1126 S> */ B(LdaConstant), U8(92),
- /* 1126 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1138 S> */ B(LdaConstant), U8(93),
- /* 1138 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1150 S> */ B(LdaConstant), U8(94),
- /* 1150 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1162 S> */ B(LdaConstant), U8(95),
- /* 1162 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1174 S> */ B(LdaConstant), U8(96),
- /* 1174 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1186 S> */ B(LdaConstant), U8(97),
- /* 1186 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1198 S> */ B(LdaConstant), U8(98),
- /* 1198 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1210 S> */ B(LdaConstant), U8(99),
- /* 1210 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1222 S> */ B(LdaConstant), U8(100),
- /* 1222 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1234 S> */ B(LdaConstant), U8(101),
- /* 1234 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1246 S> */ B(LdaConstant), U8(102),
- /* 1246 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1258 S> */ B(LdaConstant), U8(103),
- /* 1258 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1270 S> */ B(LdaConstant), U8(104),
- /* 1270 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1282 S> */ B(LdaConstant), U8(105),
- /* 1282 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1294 S> */ B(LdaConstant), U8(106),
- /* 1294 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1306 S> */ B(LdaConstant), U8(107),
- /* 1306 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1318 S> */ B(LdaConstant), U8(108),
- /* 1318 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1330 S> */ B(LdaConstant), U8(109),
- /* 1330 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1342 S> */ B(LdaConstant), U8(110),
- /* 1342 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1354 S> */ B(LdaConstant), U8(111),
- /* 1354 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1366 S> */ B(LdaConstant), U8(112),
- /* 1366 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1378 S> */ B(LdaConstant), U8(113),
- /* 1378 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1390 S> */ B(LdaConstant), U8(114),
- /* 1390 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1402 S> */ B(LdaConstant), U8(115),
- /* 1402 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1414 S> */ B(LdaConstant), U8(116),
- /* 1414 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1426 S> */ B(LdaConstant), U8(117),
- /* 1426 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1438 S> */ B(LdaConstant), U8(118),
- /* 1438 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1450 S> */ B(LdaConstant), U8(119),
- /* 1450 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1462 S> */ B(LdaConstant), U8(120),
- /* 1462 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1474 S> */ B(LdaConstant), U8(121),
- /* 1474 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1486 S> */ B(LdaConstant), U8(122),
- /* 1486 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1498 S> */ B(LdaConstant), U8(123),
- /* 1498 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1510 S> */ B(LdaConstant), U8(124),
- /* 1510 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1522 S> */ B(LdaConstant), U8(125),
- /* 1522 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1534 S> */ B(LdaConstant), U8(126),
- /* 1534 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1546 S> */ B(LdaConstant), U8(127),
- /* 1546 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1558 S> */ B(LdaConstant), U8(128),
- /* 1558 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1570 S> */ B(LdaConstant), U8(129),
- /* 1570 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1582 S> */ B(LdaConstant), U8(130),
- /* 1582 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1594 S> */ B(LdaConstant), U8(131),
- /* 1594 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1606 S> */ B(LdaConstant), U8(132),
- /* 1606 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1618 S> */ B(LdaConstant), U8(133),
- /* 1618 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1630 S> */ B(LdaConstant), U8(134),
- /* 1630 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1642 S> */ B(LdaConstant), U8(135),
- /* 1642 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1654 S> */ B(LdaConstant), U8(136),
- /* 1654 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1666 S> */ B(LdaConstant), U8(137),
- /* 1666 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1678 S> */ B(LdaConstant), U8(138),
- /* 1678 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1690 S> */ B(LdaConstant), U8(139),
- /* 1690 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1702 S> */ B(LdaConstant), U8(140),
- /* 1702 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1714 S> */ B(LdaConstant), U8(141),
- /* 1714 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1726 S> */ B(LdaConstant), U8(142),
- /* 1726 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1738 S> */ B(LdaConstant), U8(143),
- /* 1738 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1750 S> */ B(LdaConstant), U8(144),
- /* 1750 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1762 S> */ B(LdaConstant), U8(145),
- /* 1762 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1774 S> */ B(LdaConstant), U8(146),
- /* 1774 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1786 S> */ B(LdaConstant), U8(147),
- /* 1786 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1798 S> */ B(LdaConstant), U8(148),
- /* 1798 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1810 S> */ B(LdaConstant), U8(149),
- /* 1810 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1822 S> */ B(LdaConstant), U8(150),
- /* 1822 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1834 S> */ B(LdaConstant), U8(151),
- /* 1834 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1846 S> */ B(LdaConstant), U8(152),
- /* 1846 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1858 S> */ B(LdaConstant), U8(153),
- /* 1858 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1870 S> */ B(LdaConstant), U8(154),
- /* 1870 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1882 S> */ B(LdaConstant), U8(155),
- /* 1882 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1894 S> */ B(LdaConstant), U8(156),
- /* 1894 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1906 S> */ B(LdaConstant), U8(157),
- /* 1906 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1918 S> */ B(LdaConstant), U8(158),
- /* 1918 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1930 S> */ B(LdaConstant), U8(159),
- /* 1930 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1942 S> */ B(LdaConstant), U8(160),
- /* 1942 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1954 S> */ B(LdaConstant), U8(161),
- /* 1954 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1966 S> */ B(LdaConstant), U8(162),
- /* 1966 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1978 S> */ B(LdaConstant), U8(163),
- /* 1978 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1990 S> */ B(LdaConstant), U8(164),
- /* 1990 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2002 S> */ B(LdaConstant), U8(165),
- /* 2002 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2014 S> */ B(LdaConstant), U8(166),
- /* 2014 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2026 S> */ B(LdaConstant), U8(167),
- /* 2026 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2038 S> */ B(LdaConstant), U8(168),
- /* 2038 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2050 S> */ B(LdaConstant), U8(169),
- /* 2050 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2062 S> */ B(LdaConstant), U8(170),
- /* 2062 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2074 S> */ B(LdaConstant), U8(171),
- /* 2074 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2086 S> */ B(LdaConstant), U8(172),
- /* 2086 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2098 S> */ B(LdaConstant), U8(173),
- /* 2098 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2110 S> */ B(LdaConstant), U8(174),
- /* 2110 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2122 S> */ B(LdaConstant), U8(175),
- /* 2122 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2134 S> */ B(LdaConstant), U8(176),
- /* 2134 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2146 S> */ B(LdaConstant), U8(177),
- /* 2146 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2158 S> */ B(LdaConstant), U8(178),
- /* 2158 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2170 S> */ B(LdaConstant), U8(179),
- /* 2170 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2182 S> */ B(LdaConstant), U8(180),
- /* 2182 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2194 S> */ B(LdaConstant), U8(181),
- /* 2194 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2206 S> */ B(LdaConstant), U8(182),
- /* 2206 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2218 S> */ B(LdaConstant), U8(183),
- /* 2218 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2230 S> */ B(LdaConstant), U8(184),
- /* 2230 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2242 S> */ B(LdaConstant), U8(185),
- /* 2242 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2254 S> */ B(LdaConstant), U8(186),
- /* 2254 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2266 S> */ B(LdaConstant), U8(187),
- /* 2266 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2278 S> */ B(LdaConstant), U8(188),
- /* 2278 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2290 S> */ B(LdaConstant), U8(189),
- /* 2290 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2302 S> */ B(LdaConstant), U8(190),
- /* 2302 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2314 S> */ B(LdaConstant), U8(191),
- /* 2314 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2326 S> */ B(LdaConstant), U8(192),
- /* 2326 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2338 S> */ B(LdaConstant), U8(193),
- /* 2338 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2350 S> */ B(LdaConstant), U8(194),
- /* 2350 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2362 S> */ B(LdaConstant), U8(195),
- /* 2362 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2374 S> */ B(LdaConstant), U8(196),
- /* 2374 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2386 S> */ B(LdaConstant), U8(197),
- /* 2386 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2398 S> */ B(LdaConstant), U8(198),
- /* 2398 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2410 S> */ B(LdaConstant), U8(199),
- /* 2410 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2422 S> */ B(LdaConstant), U8(200),
- /* 2422 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2434 S> */ B(LdaConstant), U8(201),
- /* 2434 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2446 S> */ B(LdaConstant), U8(202),
- /* 2446 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2458 S> */ B(LdaConstant), U8(203),
- /* 2458 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2470 S> */ B(LdaConstant), U8(204),
- /* 2470 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2482 S> */ B(LdaConstant), U8(205),
- /* 2482 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2494 S> */ B(LdaConstant), U8(206),
- /* 2494 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2506 S> */ B(LdaConstant), U8(207),
- /* 2506 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2518 S> */ B(LdaConstant), U8(208),
- /* 2518 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2530 S> */ B(LdaConstant), U8(209),
- /* 2530 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2542 S> */ B(LdaConstant), U8(210),
- /* 2542 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2554 S> */ B(LdaConstant), U8(211),
- /* 2554 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2566 S> */ B(LdaConstant), U8(212),
- /* 2566 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2578 S> */ B(LdaConstant), U8(213),
- /* 2578 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2590 S> */ B(LdaConstant), U8(214),
- /* 2590 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2602 S> */ B(LdaConstant), U8(215),
- /* 2602 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2614 S> */ B(LdaConstant), U8(216),
- /* 2614 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2626 S> */ B(LdaConstant), U8(217),
- /* 2626 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2638 S> */ B(LdaConstant), U8(218),
- /* 2638 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2650 S> */ B(LdaConstant), U8(219),
- /* 2650 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2662 S> */ B(LdaConstant), U8(220),
- /* 2662 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2674 S> */ B(LdaConstant), U8(221),
- /* 2674 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2686 S> */ B(LdaConstant), U8(222),
- /* 2686 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2698 S> */ B(LdaConstant), U8(223),
- /* 2698 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2710 S> */ B(LdaConstant), U8(224),
- /* 2710 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2722 S> */ B(LdaConstant), U8(225),
- /* 2722 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2734 S> */ B(LdaConstant), U8(226),
- /* 2734 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2746 S> */ B(LdaConstant), U8(227),
- /* 2746 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2758 S> */ B(LdaConstant), U8(228),
- /* 2758 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2770 S> */ B(LdaConstant), U8(229),
- /* 2770 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2782 S> */ B(LdaConstant), U8(230),
- /* 2782 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2794 S> */ B(LdaConstant), U8(231),
- /* 2794 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2806 S> */ B(LdaConstant), U8(232),
- /* 2806 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2818 S> */ B(LdaConstant), U8(233),
- /* 2818 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2830 S> */ B(LdaConstant), U8(234),
- /* 2830 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2842 S> */ B(LdaConstant), U8(235),
- /* 2842 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2854 S> */ B(LdaConstant), U8(236),
- /* 2854 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2866 S> */ B(LdaConstant), U8(237),
- /* 2866 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2878 S> */ B(LdaConstant), U8(238),
- /* 2878 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2890 S> */ B(LdaConstant), U8(239),
- /* 2890 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2902 S> */ B(LdaConstant), U8(240),
- /* 2902 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2914 S> */ B(LdaConstant), U8(241),
- /* 2914 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2926 S> */ B(LdaConstant), U8(242),
- /* 2926 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2938 S> */ B(LdaConstant), U8(243),
- /* 2938 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2950 S> */ B(LdaConstant), U8(244),
- /* 2950 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2962 S> */ B(LdaConstant), U8(245),
- /* 2962 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2974 S> */ B(LdaConstant), U8(246),
- /* 2974 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2986 S> */ B(LdaConstant), U8(247),
- /* 2986 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2998 S> */ B(LdaConstant), U8(248),
- /* 2998 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3010 S> */ B(LdaConstant), U8(249),
- /* 3010 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3022 S> */ B(LdaConstant), U8(250),
- /* 3022 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3034 S> */ B(LdaConstant), U8(251),
- /* 3034 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3046 S> */ B(LdaConstant), U8(252),
- /* 3046 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3058 S> */ B(LdaConstant), U8(253),
- /* 3058 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3070 S> */ B(LdaConstant), U8(254),
- /* 3070 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3082 S> */ B(LdaConstant), U8(255),
- /* 3082 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3086 S> */ B(Wide), B(LdaLookupSlot), U16(256),
/* 3095 S> */ B(Return),
]
@@ -1334,517 +1334,517 @@
bytecodes: [
/* 10 E> */ B(StackCheck),
/* 22 S> */ B(LdaConstant), U8(0),
- /* 22 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 34 S> */ B(LdaConstant), U8(1),
- /* 34 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 46 S> */ B(LdaConstant), U8(2),
- /* 46 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 58 S> */ B(LdaConstant), U8(3),
- /* 58 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 70 S> */ B(LdaConstant), U8(4),
- /* 70 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 82 S> */ B(LdaConstant), U8(5),
- /* 82 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 94 S> */ B(LdaConstant), U8(6),
- /* 94 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 106 S> */ B(LdaConstant), U8(7),
- /* 106 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 118 S> */ B(LdaConstant), U8(8),
- /* 118 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 130 S> */ B(LdaConstant), U8(9),
- /* 130 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 142 S> */ B(LdaConstant), U8(10),
- /* 142 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 154 S> */ B(LdaConstant), U8(11),
- /* 154 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 166 S> */ B(LdaConstant), U8(12),
- /* 166 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 178 S> */ B(LdaConstant), U8(13),
- /* 178 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 190 S> */ B(LdaConstant), U8(14),
- /* 190 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 202 S> */ B(LdaConstant), U8(15),
- /* 202 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 214 S> */ B(LdaConstant), U8(16),
- /* 214 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 226 S> */ B(LdaConstant), U8(17),
- /* 226 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 238 S> */ B(LdaConstant), U8(18),
- /* 238 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 250 S> */ B(LdaConstant), U8(19),
- /* 250 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 262 S> */ B(LdaConstant), U8(20),
- /* 262 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 274 S> */ B(LdaConstant), U8(21),
- /* 274 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 286 S> */ B(LdaConstant), U8(22),
- /* 286 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 298 S> */ B(LdaConstant), U8(23),
- /* 298 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 310 S> */ B(LdaConstant), U8(24),
- /* 310 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 322 S> */ B(LdaConstant), U8(25),
- /* 322 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 334 S> */ B(LdaConstant), U8(26),
- /* 334 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 346 S> */ B(LdaConstant), U8(27),
- /* 346 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 358 S> */ B(LdaConstant), U8(28),
- /* 358 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 370 S> */ B(LdaConstant), U8(29),
- /* 370 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 382 S> */ B(LdaConstant), U8(30),
- /* 382 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 394 S> */ B(LdaConstant), U8(31),
- /* 394 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 406 S> */ B(LdaConstant), U8(32),
- /* 406 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 418 S> */ B(LdaConstant), U8(33),
- /* 418 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 430 S> */ B(LdaConstant), U8(34),
- /* 430 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 442 S> */ B(LdaConstant), U8(35),
- /* 442 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 454 S> */ B(LdaConstant), U8(36),
- /* 454 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 466 S> */ B(LdaConstant), U8(37),
- /* 466 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 478 S> */ B(LdaConstant), U8(38),
- /* 478 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 490 S> */ B(LdaConstant), U8(39),
- /* 490 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 502 S> */ B(LdaConstant), U8(40),
- /* 502 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 514 S> */ B(LdaConstant), U8(41),
- /* 514 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 526 S> */ B(LdaConstant), U8(42),
- /* 526 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 538 S> */ B(LdaConstant), U8(43),
- /* 538 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 550 S> */ B(LdaConstant), U8(44),
- /* 550 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 562 S> */ B(LdaConstant), U8(45),
- /* 562 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 574 S> */ B(LdaConstant), U8(46),
- /* 574 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 586 S> */ B(LdaConstant), U8(47),
- /* 586 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 598 S> */ B(LdaConstant), U8(48),
- /* 598 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 610 S> */ B(LdaConstant), U8(49),
- /* 610 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 622 S> */ B(LdaConstant), U8(50),
- /* 622 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 634 S> */ B(LdaConstant), U8(51),
- /* 634 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 646 S> */ B(LdaConstant), U8(52),
- /* 646 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 658 S> */ B(LdaConstant), U8(53),
- /* 658 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 670 S> */ B(LdaConstant), U8(54),
- /* 670 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 682 S> */ B(LdaConstant), U8(55),
- /* 682 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 694 S> */ B(LdaConstant), U8(56),
- /* 694 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 706 S> */ B(LdaConstant), U8(57),
- /* 706 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 718 S> */ B(LdaConstant), U8(58),
- /* 718 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 730 S> */ B(LdaConstant), U8(59),
- /* 730 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 742 S> */ B(LdaConstant), U8(60),
- /* 742 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 754 S> */ B(LdaConstant), U8(61),
- /* 754 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 766 S> */ B(LdaConstant), U8(62),
- /* 766 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 778 S> */ B(LdaConstant), U8(63),
- /* 778 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 790 S> */ B(LdaConstant), U8(64),
- /* 790 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 802 S> */ B(LdaConstant), U8(65),
- /* 802 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 814 S> */ B(LdaConstant), U8(66),
- /* 814 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 826 S> */ B(LdaConstant), U8(67),
- /* 826 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 838 S> */ B(LdaConstant), U8(68),
- /* 838 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 850 S> */ B(LdaConstant), U8(69),
- /* 850 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 862 S> */ B(LdaConstant), U8(70),
- /* 862 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 874 S> */ B(LdaConstant), U8(71),
- /* 874 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 886 S> */ B(LdaConstant), U8(72),
- /* 886 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 898 S> */ B(LdaConstant), U8(73),
- /* 898 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 910 S> */ B(LdaConstant), U8(74),
- /* 910 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 922 S> */ B(LdaConstant), U8(75),
- /* 922 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 934 S> */ B(LdaConstant), U8(76),
- /* 934 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 946 S> */ B(LdaConstant), U8(77),
- /* 946 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 958 S> */ B(LdaConstant), U8(78),
- /* 958 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 970 S> */ B(LdaConstant), U8(79),
- /* 970 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 982 S> */ B(LdaConstant), U8(80),
- /* 982 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 994 S> */ B(LdaConstant), U8(81),
- /* 994 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1006 S> */ B(LdaConstant), U8(82),
- /* 1006 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1018 S> */ B(LdaConstant), U8(83),
- /* 1018 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1030 S> */ B(LdaConstant), U8(84),
- /* 1030 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1042 S> */ B(LdaConstant), U8(85),
- /* 1042 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1054 S> */ B(LdaConstant), U8(86),
- /* 1054 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1066 S> */ B(LdaConstant), U8(87),
- /* 1066 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1078 S> */ B(LdaConstant), U8(88),
- /* 1078 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1090 S> */ B(LdaConstant), U8(89),
- /* 1090 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1102 S> */ B(LdaConstant), U8(90),
- /* 1102 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1114 S> */ B(LdaConstant), U8(91),
- /* 1114 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1126 S> */ B(LdaConstant), U8(92),
- /* 1126 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1138 S> */ B(LdaConstant), U8(93),
- /* 1138 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1150 S> */ B(LdaConstant), U8(94),
- /* 1150 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1162 S> */ B(LdaConstant), U8(95),
- /* 1162 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1174 S> */ B(LdaConstant), U8(96),
- /* 1174 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1186 S> */ B(LdaConstant), U8(97),
- /* 1186 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1198 S> */ B(LdaConstant), U8(98),
- /* 1198 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1210 S> */ B(LdaConstant), U8(99),
- /* 1210 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1222 S> */ B(LdaConstant), U8(100),
- /* 1222 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1234 S> */ B(LdaConstant), U8(101),
- /* 1234 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1246 S> */ B(LdaConstant), U8(102),
- /* 1246 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1258 S> */ B(LdaConstant), U8(103),
- /* 1258 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1270 S> */ B(LdaConstant), U8(104),
- /* 1270 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1282 S> */ B(LdaConstant), U8(105),
- /* 1282 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1294 S> */ B(LdaConstant), U8(106),
- /* 1294 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1306 S> */ B(LdaConstant), U8(107),
- /* 1306 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1318 S> */ B(LdaConstant), U8(108),
- /* 1318 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1330 S> */ B(LdaConstant), U8(109),
- /* 1330 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1342 S> */ B(LdaConstant), U8(110),
- /* 1342 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1354 S> */ B(LdaConstant), U8(111),
- /* 1354 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1366 S> */ B(LdaConstant), U8(112),
- /* 1366 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1378 S> */ B(LdaConstant), U8(113),
- /* 1378 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1390 S> */ B(LdaConstant), U8(114),
- /* 1390 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1402 S> */ B(LdaConstant), U8(115),
- /* 1402 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1414 S> */ B(LdaConstant), U8(116),
- /* 1414 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1426 S> */ B(LdaConstant), U8(117),
- /* 1426 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1438 S> */ B(LdaConstant), U8(118),
- /* 1438 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1450 S> */ B(LdaConstant), U8(119),
- /* 1450 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1462 S> */ B(LdaConstant), U8(120),
- /* 1462 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1474 S> */ B(LdaConstant), U8(121),
- /* 1474 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1486 S> */ B(LdaConstant), U8(122),
- /* 1486 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1498 S> */ B(LdaConstant), U8(123),
- /* 1498 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1510 S> */ B(LdaConstant), U8(124),
- /* 1510 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1522 S> */ B(LdaConstant), U8(125),
- /* 1522 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1534 S> */ B(LdaConstant), U8(126),
- /* 1534 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1546 S> */ B(LdaConstant), U8(127),
- /* 1546 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1558 S> */ B(LdaConstant), U8(128),
- /* 1558 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1570 S> */ B(LdaConstant), U8(129),
- /* 1570 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1582 S> */ B(LdaConstant), U8(130),
- /* 1582 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1594 S> */ B(LdaConstant), U8(131),
- /* 1594 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1606 S> */ B(LdaConstant), U8(132),
- /* 1606 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1618 S> */ B(LdaConstant), U8(133),
- /* 1618 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1630 S> */ B(LdaConstant), U8(134),
- /* 1630 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1642 S> */ B(LdaConstant), U8(135),
- /* 1642 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1654 S> */ B(LdaConstant), U8(136),
- /* 1654 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1666 S> */ B(LdaConstant), U8(137),
- /* 1666 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1678 S> */ B(LdaConstant), U8(138),
- /* 1678 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1690 S> */ B(LdaConstant), U8(139),
- /* 1690 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1702 S> */ B(LdaConstant), U8(140),
- /* 1702 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1714 S> */ B(LdaConstant), U8(141),
- /* 1714 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1726 S> */ B(LdaConstant), U8(142),
- /* 1726 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1738 S> */ B(LdaConstant), U8(143),
- /* 1738 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1750 S> */ B(LdaConstant), U8(144),
- /* 1750 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1762 S> */ B(LdaConstant), U8(145),
- /* 1762 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1774 S> */ B(LdaConstant), U8(146),
- /* 1774 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1786 S> */ B(LdaConstant), U8(147),
- /* 1786 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1798 S> */ B(LdaConstant), U8(148),
- /* 1798 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1810 S> */ B(LdaConstant), U8(149),
- /* 1810 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1822 S> */ B(LdaConstant), U8(150),
- /* 1822 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1834 S> */ B(LdaConstant), U8(151),
- /* 1834 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1846 S> */ B(LdaConstant), U8(152),
- /* 1846 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1858 S> */ B(LdaConstant), U8(153),
- /* 1858 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1870 S> */ B(LdaConstant), U8(154),
- /* 1870 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1882 S> */ B(LdaConstant), U8(155),
- /* 1882 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1894 S> */ B(LdaConstant), U8(156),
- /* 1894 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1906 S> */ B(LdaConstant), U8(157),
- /* 1906 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1918 S> */ B(LdaConstant), U8(158),
- /* 1918 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1930 S> */ B(LdaConstant), U8(159),
- /* 1930 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1942 S> */ B(LdaConstant), U8(160),
- /* 1942 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1954 S> */ B(LdaConstant), U8(161),
- /* 1954 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1966 S> */ B(LdaConstant), U8(162),
- /* 1966 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1978 S> */ B(LdaConstant), U8(163),
- /* 1978 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1990 S> */ B(LdaConstant), U8(164),
- /* 1990 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2002 S> */ B(LdaConstant), U8(165),
- /* 2002 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2014 S> */ B(LdaConstant), U8(166),
- /* 2014 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2026 S> */ B(LdaConstant), U8(167),
- /* 2026 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2038 S> */ B(LdaConstant), U8(168),
- /* 2038 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2050 S> */ B(LdaConstant), U8(169),
- /* 2050 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2062 S> */ B(LdaConstant), U8(170),
- /* 2062 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2074 S> */ B(LdaConstant), U8(171),
- /* 2074 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2086 S> */ B(LdaConstant), U8(172),
- /* 2086 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2098 S> */ B(LdaConstant), U8(173),
- /* 2098 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2110 S> */ B(LdaConstant), U8(174),
- /* 2110 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2122 S> */ B(LdaConstant), U8(175),
- /* 2122 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2134 S> */ B(LdaConstant), U8(176),
- /* 2134 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2146 S> */ B(LdaConstant), U8(177),
- /* 2146 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2158 S> */ B(LdaConstant), U8(178),
- /* 2158 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2170 S> */ B(LdaConstant), U8(179),
- /* 2170 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2182 S> */ B(LdaConstant), U8(180),
- /* 2182 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2194 S> */ B(LdaConstant), U8(181),
- /* 2194 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2206 S> */ B(LdaConstant), U8(182),
- /* 2206 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2218 S> */ B(LdaConstant), U8(183),
- /* 2218 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2230 S> */ B(LdaConstant), U8(184),
- /* 2230 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2242 S> */ B(LdaConstant), U8(185),
- /* 2242 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2254 S> */ B(LdaConstant), U8(186),
- /* 2254 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2266 S> */ B(LdaConstant), U8(187),
- /* 2266 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2278 S> */ B(LdaConstant), U8(188),
- /* 2278 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2290 S> */ B(LdaConstant), U8(189),
- /* 2290 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2302 S> */ B(LdaConstant), U8(190),
- /* 2302 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2314 S> */ B(LdaConstant), U8(191),
- /* 2314 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2326 S> */ B(LdaConstant), U8(192),
- /* 2326 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2338 S> */ B(LdaConstant), U8(193),
- /* 2338 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2350 S> */ B(LdaConstant), U8(194),
- /* 2350 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2362 S> */ B(LdaConstant), U8(195),
- /* 2362 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2374 S> */ B(LdaConstant), U8(196),
- /* 2374 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2386 S> */ B(LdaConstant), U8(197),
- /* 2386 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2398 S> */ B(LdaConstant), U8(198),
- /* 2398 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2410 S> */ B(LdaConstant), U8(199),
- /* 2410 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2422 S> */ B(LdaConstant), U8(200),
- /* 2422 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2434 S> */ B(LdaConstant), U8(201),
- /* 2434 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2446 S> */ B(LdaConstant), U8(202),
- /* 2446 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2458 S> */ B(LdaConstant), U8(203),
- /* 2458 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2470 S> */ B(LdaConstant), U8(204),
- /* 2470 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2482 S> */ B(LdaConstant), U8(205),
- /* 2482 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2494 S> */ B(LdaConstant), U8(206),
- /* 2494 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2506 S> */ B(LdaConstant), U8(207),
- /* 2506 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2518 S> */ B(LdaConstant), U8(208),
- /* 2518 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2530 S> */ B(LdaConstant), U8(209),
- /* 2530 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2542 S> */ B(LdaConstant), U8(210),
- /* 2542 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2554 S> */ B(LdaConstant), U8(211),
- /* 2554 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2566 S> */ B(LdaConstant), U8(212),
- /* 2566 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2578 S> */ B(LdaConstant), U8(213),
- /* 2578 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2590 S> */ B(LdaConstant), U8(214),
- /* 2590 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2602 S> */ B(LdaConstant), U8(215),
- /* 2602 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2614 S> */ B(LdaConstant), U8(216),
- /* 2614 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2626 S> */ B(LdaConstant), U8(217),
- /* 2626 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2638 S> */ B(LdaConstant), U8(218),
- /* 2638 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2650 S> */ B(LdaConstant), U8(219),
- /* 2650 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2662 S> */ B(LdaConstant), U8(220),
- /* 2662 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2674 S> */ B(LdaConstant), U8(221),
- /* 2674 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2686 S> */ B(LdaConstant), U8(222),
- /* 2686 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2698 S> */ B(LdaConstant), U8(223),
- /* 2698 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2710 S> */ B(LdaConstant), U8(224),
- /* 2710 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2722 S> */ B(LdaConstant), U8(225),
- /* 2722 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2734 S> */ B(LdaConstant), U8(226),
- /* 2734 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2746 S> */ B(LdaConstant), U8(227),
- /* 2746 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2758 S> */ B(LdaConstant), U8(228),
- /* 2758 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2770 S> */ B(LdaConstant), U8(229),
- /* 2770 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2782 S> */ B(LdaConstant), U8(230),
- /* 2782 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2794 S> */ B(LdaConstant), U8(231),
- /* 2794 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2806 S> */ B(LdaConstant), U8(232),
- /* 2806 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2818 S> */ B(LdaConstant), U8(233),
- /* 2818 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2830 S> */ B(LdaConstant), U8(234),
- /* 2830 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2842 S> */ B(LdaConstant), U8(235),
- /* 2842 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2854 S> */ B(LdaConstant), U8(236),
- /* 2854 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2866 S> */ B(LdaConstant), U8(237),
- /* 2866 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2878 S> */ B(LdaConstant), U8(238),
- /* 2878 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2890 S> */ B(LdaConstant), U8(239),
- /* 2890 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2902 S> */ B(LdaConstant), U8(240),
- /* 2902 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2914 S> */ B(LdaConstant), U8(241),
- /* 2914 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2926 S> */ B(LdaConstant), U8(242),
- /* 2926 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2938 S> */ B(LdaConstant), U8(243),
- /* 2938 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2950 S> */ B(LdaConstant), U8(244),
- /* 2950 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2962 S> */ B(LdaConstant), U8(245),
- /* 2962 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2974 S> */ B(LdaConstant), U8(246),
- /* 2974 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2986 S> */ B(LdaConstant), U8(247),
- /* 2986 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2998 S> */ B(LdaConstant), U8(248),
- /* 2998 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3010 S> */ B(LdaConstant), U8(249),
- /* 3010 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3022 S> */ B(LdaConstant), U8(250),
- /* 3022 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3034 S> */ B(LdaConstant), U8(251),
- /* 3034 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3046 S> */ B(LdaConstant), U8(252),
- /* 3046 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3058 S> */ B(LdaConstant), U8(253),
- /* 3058 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3070 S> */ B(LdaConstant), U8(254),
- /* 3070 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3082 S> */ B(LdaConstant), U8(255),
- /* 3082 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3086 S> */ B(Wide), B(LdaLookupSlotInsideTypeof), U16(256),
B(TypeOf),
/* 3102 S> */ B(Return),
@@ -2386,517 +2386,517 @@
bytecodes: [
/* 10 E> */ B(StackCheck),
/* 22 S> */ B(LdaConstant), U8(0),
- /* 22 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 34 S> */ B(LdaConstant), U8(1),
- /* 34 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 46 S> */ B(LdaConstant), U8(2),
- /* 46 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 58 S> */ B(LdaConstant), U8(3),
- /* 58 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 70 S> */ B(LdaConstant), U8(4),
- /* 70 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 82 S> */ B(LdaConstant), U8(5),
- /* 82 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 94 S> */ B(LdaConstant), U8(6),
- /* 94 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 106 S> */ B(LdaConstant), U8(7),
- /* 106 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 118 S> */ B(LdaConstant), U8(8),
- /* 118 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 130 S> */ B(LdaConstant), U8(9),
- /* 130 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 142 S> */ B(LdaConstant), U8(10),
- /* 142 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 154 S> */ B(LdaConstant), U8(11),
- /* 154 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 166 S> */ B(LdaConstant), U8(12),
- /* 166 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 178 S> */ B(LdaConstant), U8(13),
- /* 178 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 190 S> */ B(LdaConstant), U8(14),
- /* 190 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 202 S> */ B(LdaConstant), U8(15),
- /* 202 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 214 S> */ B(LdaConstant), U8(16),
- /* 214 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 226 S> */ B(LdaConstant), U8(17),
- /* 226 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 238 S> */ B(LdaConstant), U8(18),
- /* 238 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 250 S> */ B(LdaConstant), U8(19),
- /* 250 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 262 S> */ B(LdaConstant), U8(20),
- /* 262 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 274 S> */ B(LdaConstant), U8(21),
- /* 274 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 286 S> */ B(LdaConstant), U8(22),
- /* 286 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 298 S> */ B(LdaConstant), U8(23),
- /* 298 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 310 S> */ B(LdaConstant), U8(24),
- /* 310 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 322 S> */ B(LdaConstant), U8(25),
- /* 322 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 334 S> */ B(LdaConstant), U8(26),
- /* 334 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 346 S> */ B(LdaConstant), U8(27),
- /* 346 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 358 S> */ B(LdaConstant), U8(28),
- /* 358 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 370 S> */ B(LdaConstant), U8(29),
- /* 370 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 382 S> */ B(LdaConstant), U8(30),
- /* 382 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 394 S> */ B(LdaConstant), U8(31),
- /* 394 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 406 S> */ B(LdaConstant), U8(32),
- /* 406 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 418 S> */ B(LdaConstant), U8(33),
- /* 418 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 430 S> */ B(LdaConstant), U8(34),
- /* 430 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 442 S> */ B(LdaConstant), U8(35),
- /* 442 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 454 S> */ B(LdaConstant), U8(36),
- /* 454 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 466 S> */ B(LdaConstant), U8(37),
- /* 466 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 478 S> */ B(LdaConstant), U8(38),
- /* 478 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 490 S> */ B(LdaConstant), U8(39),
- /* 490 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 502 S> */ B(LdaConstant), U8(40),
- /* 502 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 514 S> */ B(LdaConstant), U8(41),
- /* 514 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 526 S> */ B(LdaConstant), U8(42),
- /* 526 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 538 S> */ B(LdaConstant), U8(43),
- /* 538 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 550 S> */ B(LdaConstant), U8(44),
- /* 550 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 562 S> */ B(LdaConstant), U8(45),
- /* 562 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 574 S> */ B(LdaConstant), U8(46),
- /* 574 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 586 S> */ B(LdaConstant), U8(47),
- /* 586 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 598 S> */ B(LdaConstant), U8(48),
- /* 598 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 610 S> */ B(LdaConstant), U8(49),
- /* 610 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 622 S> */ B(LdaConstant), U8(50),
- /* 622 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 634 S> */ B(LdaConstant), U8(51),
- /* 634 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 646 S> */ B(LdaConstant), U8(52),
- /* 646 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 658 S> */ B(LdaConstant), U8(53),
- /* 658 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 670 S> */ B(LdaConstant), U8(54),
- /* 670 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 682 S> */ B(LdaConstant), U8(55),
- /* 682 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 694 S> */ B(LdaConstant), U8(56),
- /* 694 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 706 S> */ B(LdaConstant), U8(57),
- /* 706 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 718 S> */ B(LdaConstant), U8(58),
- /* 718 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 730 S> */ B(LdaConstant), U8(59),
- /* 730 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 742 S> */ B(LdaConstant), U8(60),
- /* 742 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 754 S> */ B(LdaConstant), U8(61),
- /* 754 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 766 S> */ B(LdaConstant), U8(62),
- /* 766 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 778 S> */ B(LdaConstant), U8(63),
- /* 778 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 790 S> */ B(LdaConstant), U8(64),
- /* 790 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 802 S> */ B(LdaConstant), U8(65),
- /* 802 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 814 S> */ B(LdaConstant), U8(66),
- /* 814 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 826 S> */ B(LdaConstant), U8(67),
- /* 826 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 838 S> */ B(LdaConstant), U8(68),
- /* 838 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 850 S> */ B(LdaConstant), U8(69),
- /* 850 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 862 S> */ B(LdaConstant), U8(70),
- /* 862 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 874 S> */ B(LdaConstant), U8(71),
- /* 874 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 886 S> */ B(LdaConstant), U8(72),
- /* 886 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 898 S> */ B(LdaConstant), U8(73),
- /* 898 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 910 S> */ B(LdaConstant), U8(74),
- /* 910 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 922 S> */ B(LdaConstant), U8(75),
- /* 922 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 934 S> */ B(LdaConstant), U8(76),
- /* 934 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 946 S> */ B(LdaConstant), U8(77),
- /* 946 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 958 S> */ B(LdaConstant), U8(78),
- /* 958 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 970 S> */ B(LdaConstant), U8(79),
- /* 970 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 982 S> */ B(LdaConstant), U8(80),
- /* 982 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 994 S> */ B(LdaConstant), U8(81),
- /* 994 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1006 S> */ B(LdaConstant), U8(82),
- /* 1006 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1018 S> */ B(LdaConstant), U8(83),
- /* 1018 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1030 S> */ B(LdaConstant), U8(84),
- /* 1030 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1042 S> */ B(LdaConstant), U8(85),
- /* 1042 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1054 S> */ B(LdaConstant), U8(86),
- /* 1054 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1066 S> */ B(LdaConstant), U8(87),
- /* 1066 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1078 S> */ B(LdaConstant), U8(88),
- /* 1078 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1090 S> */ B(LdaConstant), U8(89),
- /* 1090 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1102 S> */ B(LdaConstant), U8(90),
- /* 1102 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1114 S> */ B(LdaConstant), U8(91),
- /* 1114 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1126 S> */ B(LdaConstant), U8(92),
- /* 1126 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1138 S> */ B(LdaConstant), U8(93),
- /* 1138 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1150 S> */ B(LdaConstant), U8(94),
- /* 1150 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1162 S> */ B(LdaConstant), U8(95),
- /* 1162 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1174 S> */ B(LdaConstant), U8(96),
- /* 1174 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1186 S> */ B(LdaConstant), U8(97),
- /* 1186 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1198 S> */ B(LdaConstant), U8(98),
- /* 1198 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1210 S> */ B(LdaConstant), U8(99),
- /* 1210 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1222 S> */ B(LdaConstant), U8(100),
- /* 1222 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1234 S> */ B(LdaConstant), U8(101),
- /* 1234 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1246 S> */ B(LdaConstant), U8(102),
- /* 1246 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1258 S> */ B(LdaConstant), U8(103),
- /* 1258 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1270 S> */ B(LdaConstant), U8(104),
- /* 1270 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1282 S> */ B(LdaConstant), U8(105),
- /* 1282 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1294 S> */ B(LdaConstant), U8(106),
- /* 1294 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1306 S> */ B(LdaConstant), U8(107),
- /* 1306 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1318 S> */ B(LdaConstant), U8(108),
- /* 1318 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1330 S> */ B(LdaConstant), U8(109),
- /* 1330 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1342 S> */ B(LdaConstant), U8(110),
- /* 1342 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1354 S> */ B(LdaConstant), U8(111),
- /* 1354 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1366 S> */ B(LdaConstant), U8(112),
- /* 1366 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1378 S> */ B(LdaConstant), U8(113),
- /* 1378 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1390 S> */ B(LdaConstant), U8(114),
- /* 1390 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1402 S> */ B(LdaConstant), U8(115),
- /* 1402 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1414 S> */ B(LdaConstant), U8(116),
- /* 1414 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1426 S> */ B(LdaConstant), U8(117),
- /* 1426 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1438 S> */ B(LdaConstant), U8(118),
- /* 1438 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1450 S> */ B(LdaConstant), U8(119),
- /* 1450 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1462 S> */ B(LdaConstant), U8(120),
- /* 1462 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1474 S> */ B(LdaConstant), U8(121),
- /* 1474 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1486 S> */ B(LdaConstant), U8(122),
- /* 1486 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1498 S> */ B(LdaConstant), U8(123),
- /* 1498 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1510 S> */ B(LdaConstant), U8(124),
- /* 1510 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1522 S> */ B(LdaConstant), U8(125),
- /* 1522 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1534 S> */ B(LdaConstant), U8(126),
- /* 1534 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1546 S> */ B(LdaConstant), U8(127),
- /* 1546 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1558 S> */ B(LdaConstant), U8(128),
- /* 1558 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1570 S> */ B(LdaConstant), U8(129),
- /* 1570 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1582 S> */ B(LdaConstant), U8(130),
- /* 1582 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1594 S> */ B(LdaConstant), U8(131),
- /* 1594 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1606 S> */ B(LdaConstant), U8(132),
- /* 1606 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1618 S> */ B(LdaConstant), U8(133),
- /* 1618 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1630 S> */ B(LdaConstant), U8(134),
- /* 1630 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1642 S> */ B(LdaConstant), U8(135),
- /* 1642 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1654 S> */ B(LdaConstant), U8(136),
- /* 1654 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1666 S> */ B(LdaConstant), U8(137),
- /* 1666 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1678 S> */ B(LdaConstant), U8(138),
- /* 1678 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1690 S> */ B(LdaConstant), U8(139),
- /* 1690 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1702 S> */ B(LdaConstant), U8(140),
- /* 1702 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1714 S> */ B(LdaConstant), U8(141),
- /* 1714 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1726 S> */ B(LdaConstant), U8(142),
- /* 1726 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1738 S> */ B(LdaConstant), U8(143),
- /* 1738 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1750 S> */ B(LdaConstant), U8(144),
- /* 1750 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1762 S> */ B(LdaConstant), U8(145),
- /* 1762 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1774 S> */ B(LdaConstant), U8(146),
- /* 1774 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1786 S> */ B(LdaConstant), U8(147),
- /* 1786 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1798 S> */ B(LdaConstant), U8(148),
- /* 1798 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1810 S> */ B(LdaConstant), U8(149),
- /* 1810 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1822 S> */ B(LdaConstant), U8(150),
- /* 1822 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1834 S> */ B(LdaConstant), U8(151),
- /* 1834 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1846 S> */ B(LdaConstant), U8(152),
- /* 1846 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1858 S> */ B(LdaConstant), U8(153),
- /* 1858 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1870 S> */ B(LdaConstant), U8(154),
- /* 1870 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1882 S> */ B(LdaConstant), U8(155),
- /* 1882 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1894 S> */ B(LdaConstant), U8(156),
- /* 1894 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1906 S> */ B(LdaConstant), U8(157),
- /* 1906 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1918 S> */ B(LdaConstant), U8(158),
- /* 1918 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1930 S> */ B(LdaConstant), U8(159),
- /* 1930 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1942 S> */ B(LdaConstant), U8(160),
- /* 1942 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1954 S> */ B(LdaConstant), U8(161),
- /* 1954 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1966 S> */ B(LdaConstant), U8(162),
- /* 1966 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1978 S> */ B(LdaConstant), U8(163),
- /* 1978 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1990 S> */ B(LdaConstant), U8(164),
- /* 1990 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2002 S> */ B(LdaConstant), U8(165),
- /* 2002 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2014 S> */ B(LdaConstant), U8(166),
- /* 2014 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2026 S> */ B(LdaConstant), U8(167),
- /* 2026 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2038 S> */ B(LdaConstant), U8(168),
- /* 2038 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2050 S> */ B(LdaConstant), U8(169),
- /* 2050 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2062 S> */ B(LdaConstant), U8(170),
- /* 2062 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2074 S> */ B(LdaConstant), U8(171),
- /* 2074 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2086 S> */ B(LdaConstant), U8(172),
- /* 2086 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2098 S> */ B(LdaConstant), U8(173),
- /* 2098 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2110 S> */ B(LdaConstant), U8(174),
- /* 2110 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2122 S> */ B(LdaConstant), U8(175),
- /* 2122 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2134 S> */ B(LdaConstant), U8(176),
- /* 2134 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2146 S> */ B(LdaConstant), U8(177),
- /* 2146 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2158 S> */ B(LdaConstant), U8(178),
- /* 2158 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2170 S> */ B(LdaConstant), U8(179),
- /* 2170 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2182 S> */ B(LdaConstant), U8(180),
- /* 2182 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2194 S> */ B(LdaConstant), U8(181),
- /* 2194 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2206 S> */ B(LdaConstant), U8(182),
- /* 2206 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2218 S> */ B(LdaConstant), U8(183),
- /* 2218 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2230 S> */ B(LdaConstant), U8(184),
- /* 2230 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2242 S> */ B(LdaConstant), U8(185),
- /* 2242 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2254 S> */ B(LdaConstant), U8(186),
- /* 2254 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2266 S> */ B(LdaConstant), U8(187),
- /* 2266 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2278 S> */ B(LdaConstant), U8(188),
- /* 2278 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2290 S> */ B(LdaConstant), U8(189),
- /* 2290 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2302 S> */ B(LdaConstant), U8(190),
- /* 2302 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2314 S> */ B(LdaConstant), U8(191),
- /* 2314 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2326 S> */ B(LdaConstant), U8(192),
- /* 2326 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2338 S> */ B(LdaConstant), U8(193),
- /* 2338 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2350 S> */ B(LdaConstant), U8(194),
- /* 2350 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2362 S> */ B(LdaConstant), U8(195),
- /* 2362 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2374 S> */ B(LdaConstant), U8(196),
- /* 2374 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2386 S> */ B(LdaConstant), U8(197),
- /* 2386 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2398 S> */ B(LdaConstant), U8(198),
- /* 2398 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2410 S> */ B(LdaConstant), U8(199),
- /* 2410 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2422 S> */ B(LdaConstant), U8(200),
- /* 2422 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2434 S> */ B(LdaConstant), U8(201),
- /* 2434 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2446 S> */ B(LdaConstant), U8(202),
- /* 2446 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2458 S> */ B(LdaConstant), U8(203),
- /* 2458 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2470 S> */ B(LdaConstant), U8(204),
- /* 2470 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2482 S> */ B(LdaConstant), U8(205),
- /* 2482 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2494 S> */ B(LdaConstant), U8(206),
- /* 2494 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2506 S> */ B(LdaConstant), U8(207),
- /* 2506 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2518 S> */ B(LdaConstant), U8(208),
- /* 2518 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2530 S> */ B(LdaConstant), U8(209),
- /* 2530 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2542 S> */ B(LdaConstant), U8(210),
- /* 2542 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2554 S> */ B(LdaConstant), U8(211),
- /* 2554 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2566 S> */ B(LdaConstant), U8(212),
- /* 2566 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2578 S> */ B(LdaConstant), U8(213),
- /* 2578 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2590 S> */ B(LdaConstant), U8(214),
- /* 2590 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2602 S> */ B(LdaConstant), U8(215),
- /* 2602 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2614 S> */ B(LdaConstant), U8(216),
- /* 2614 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2626 S> */ B(LdaConstant), U8(217),
- /* 2626 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2638 S> */ B(LdaConstant), U8(218),
- /* 2638 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2650 S> */ B(LdaConstant), U8(219),
- /* 2650 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2662 S> */ B(LdaConstant), U8(220),
- /* 2662 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2674 S> */ B(LdaConstant), U8(221),
- /* 2674 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2686 S> */ B(LdaConstant), U8(222),
- /* 2686 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2698 S> */ B(LdaConstant), U8(223),
- /* 2698 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2710 S> */ B(LdaConstant), U8(224),
- /* 2710 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2722 S> */ B(LdaConstant), U8(225),
- /* 2722 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2734 S> */ B(LdaConstant), U8(226),
- /* 2734 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2746 S> */ B(LdaConstant), U8(227),
- /* 2746 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2758 S> */ B(LdaConstant), U8(228),
- /* 2758 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2770 S> */ B(LdaConstant), U8(229),
- /* 2770 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2782 S> */ B(LdaConstant), U8(230),
- /* 2782 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2794 S> */ B(LdaConstant), U8(231),
- /* 2794 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2806 S> */ B(LdaConstant), U8(232),
- /* 2806 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2818 S> */ B(LdaConstant), U8(233),
- /* 2818 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2830 S> */ B(LdaConstant), U8(234),
- /* 2830 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2842 S> */ B(LdaConstant), U8(235),
- /* 2842 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2854 S> */ B(LdaConstant), U8(236),
- /* 2854 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2866 S> */ B(LdaConstant), U8(237),
- /* 2866 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2878 S> */ B(LdaConstant), U8(238),
- /* 2878 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2890 S> */ B(LdaConstant), U8(239),
- /* 2890 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2902 S> */ B(LdaConstant), U8(240),
- /* 2902 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2914 S> */ B(LdaConstant), U8(241),
- /* 2914 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2926 S> */ B(LdaConstant), U8(242),
- /* 2926 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2938 S> */ B(LdaConstant), U8(243),
- /* 2938 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2950 S> */ B(LdaConstant), U8(244),
- /* 2950 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2962 S> */ B(LdaConstant), U8(245),
- /* 2962 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2974 S> */ B(LdaConstant), U8(246),
- /* 2974 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2986 S> */ B(LdaConstant), U8(247),
- /* 2986 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2998 S> */ B(LdaConstant), U8(248),
- /* 2998 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3010 S> */ B(LdaConstant), U8(249),
- /* 3010 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3022 S> */ B(LdaConstant), U8(250),
- /* 3022 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3034 S> */ B(LdaConstant), U8(251),
- /* 3034 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3046 S> */ B(LdaConstant), U8(252),
- /* 3046 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3058 S> */ B(LdaConstant), U8(253),
- /* 3058 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3070 S> */ B(LdaConstant), U8(254),
- /* 3070 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3082 S> */ B(LdaConstant), U8(255),
- /* 3082 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3086 S> */ B(LdaSmi), U8(10),
/* 3088 E> */ B(Wide), B(StaLookupSlotSloppy), U16(256),
B(LdaUndefined),
@@ -3440,517 +3440,517 @@
bytecodes: [
/* 10 E> */ B(StackCheck),
/* 35 S> */ B(LdaConstant), U8(0),
- /* 35 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 47 S> */ B(LdaConstant), U8(1),
- /* 47 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 59 S> */ B(LdaConstant), U8(2),
- /* 59 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 71 S> */ B(LdaConstant), U8(3),
- /* 71 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 83 S> */ B(LdaConstant), U8(4),
- /* 83 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 95 S> */ B(LdaConstant), U8(5),
- /* 95 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 107 S> */ B(LdaConstant), U8(6),
- /* 107 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 119 S> */ B(LdaConstant), U8(7),
- /* 119 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 131 S> */ B(LdaConstant), U8(8),
- /* 131 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 143 S> */ B(LdaConstant), U8(9),
- /* 143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 155 S> */ B(LdaConstant), U8(10),
- /* 155 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 167 S> */ B(LdaConstant), U8(11),
- /* 167 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 179 S> */ B(LdaConstant), U8(12),
- /* 179 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 191 S> */ B(LdaConstant), U8(13),
- /* 191 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 203 S> */ B(LdaConstant), U8(14),
- /* 203 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 215 S> */ B(LdaConstant), U8(15),
- /* 215 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 227 S> */ B(LdaConstant), U8(16),
- /* 227 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 239 S> */ B(LdaConstant), U8(17),
- /* 239 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 251 S> */ B(LdaConstant), U8(18),
- /* 251 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 263 S> */ B(LdaConstant), U8(19),
- /* 263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 275 S> */ B(LdaConstant), U8(20),
- /* 275 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 287 S> */ B(LdaConstant), U8(21),
- /* 287 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 299 S> */ B(LdaConstant), U8(22),
- /* 299 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 311 S> */ B(LdaConstant), U8(23),
- /* 311 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 323 S> */ B(LdaConstant), U8(24),
- /* 323 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 335 S> */ B(LdaConstant), U8(25),
- /* 335 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 347 S> */ B(LdaConstant), U8(26),
- /* 347 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 359 S> */ B(LdaConstant), U8(27),
- /* 359 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 371 S> */ B(LdaConstant), U8(28),
- /* 371 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 383 S> */ B(LdaConstant), U8(29),
- /* 383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 395 S> */ B(LdaConstant), U8(30),
- /* 395 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 407 S> */ B(LdaConstant), U8(31),
- /* 407 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 419 S> */ B(LdaConstant), U8(32),
- /* 419 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 431 S> */ B(LdaConstant), U8(33),
- /* 431 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 443 S> */ B(LdaConstant), U8(34),
- /* 443 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 455 S> */ B(LdaConstant), U8(35),
- /* 455 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 467 S> */ B(LdaConstant), U8(36),
- /* 467 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 479 S> */ B(LdaConstant), U8(37),
- /* 479 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 491 S> */ B(LdaConstant), U8(38),
- /* 491 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 503 S> */ B(LdaConstant), U8(39),
- /* 503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 515 S> */ B(LdaConstant), U8(40),
- /* 515 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 527 S> */ B(LdaConstant), U8(41),
- /* 527 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 539 S> */ B(LdaConstant), U8(42),
- /* 539 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 551 S> */ B(LdaConstant), U8(43),
- /* 551 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 563 S> */ B(LdaConstant), U8(44),
- /* 563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 575 S> */ B(LdaConstant), U8(45),
- /* 575 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 587 S> */ B(LdaConstant), U8(46),
- /* 587 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 599 S> */ B(LdaConstant), U8(47),
- /* 599 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 611 S> */ B(LdaConstant), U8(48),
- /* 611 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 623 S> */ B(LdaConstant), U8(49),
- /* 623 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 635 S> */ B(LdaConstant), U8(50),
- /* 635 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 647 S> */ B(LdaConstant), U8(51),
- /* 647 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 659 S> */ B(LdaConstant), U8(52),
- /* 659 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 671 S> */ B(LdaConstant), U8(53),
- /* 671 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 683 S> */ B(LdaConstant), U8(54),
- /* 683 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 695 S> */ B(LdaConstant), U8(55),
- /* 695 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 707 S> */ B(LdaConstant), U8(56),
- /* 707 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 719 S> */ B(LdaConstant), U8(57),
- /* 719 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 731 S> */ B(LdaConstant), U8(58),
- /* 731 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 743 S> */ B(LdaConstant), U8(59),
- /* 743 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 755 S> */ B(LdaConstant), U8(60),
- /* 755 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 767 S> */ B(LdaConstant), U8(61),
- /* 767 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 779 S> */ B(LdaConstant), U8(62),
- /* 779 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 791 S> */ B(LdaConstant), U8(63),
- /* 791 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 803 S> */ B(LdaConstant), U8(64),
- /* 803 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 815 S> */ B(LdaConstant), U8(65),
- /* 815 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 827 S> */ B(LdaConstant), U8(66),
- /* 827 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 839 S> */ B(LdaConstant), U8(67),
- /* 839 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 851 S> */ B(LdaConstant), U8(68),
- /* 851 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 863 S> */ B(LdaConstant), U8(69),
- /* 863 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 875 S> */ B(LdaConstant), U8(70),
- /* 875 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 887 S> */ B(LdaConstant), U8(71),
- /* 887 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 899 S> */ B(LdaConstant), U8(72),
- /* 899 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 911 S> */ B(LdaConstant), U8(73),
- /* 911 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 923 S> */ B(LdaConstant), U8(74),
- /* 923 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 935 S> */ B(LdaConstant), U8(75),
- /* 935 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 947 S> */ B(LdaConstant), U8(76),
- /* 947 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 959 S> */ B(LdaConstant), U8(77),
- /* 959 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 971 S> */ B(LdaConstant), U8(78),
- /* 971 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 983 S> */ B(LdaConstant), U8(79),
- /* 983 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 995 S> */ B(LdaConstant), U8(80),
- /* 995 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1007 S> */ B(LdaConstant), U8(81),
- /* 1007 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1019 S> */ B(LdaConstant), U8(82),
- /* 1019 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1031 S> */ B(LdaConstant), U8(83),
- /* 1031 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1043 S> */ B(LdaConstant), U8(84),
- /* 1043 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1055 S> */ B(LdaConstant), U8(85),
- /* 1055 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1067 S> */ B(LdaConstant), U8(86),
- /* 1067 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1079 S> */ B(LdaConstant), U8(87),
- /* 1079 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1091 S> */ B(LdaConstant), U8(88),
- /* 1091 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1103 S> */ B(LdaConstant), U8(89),
- /* 1103 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1115 S> */ B(LdaConstant), U8(90),
- /* 1115 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1127 S> */ B(LdaConstant), U8(91),
- /* 1127 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1139 S> */ B(LdaConstant), U8(92),
- /* 1139 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1151 S> */ B(LdaConstant), U8(93),
- /* 1151 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1163 S> */ B(LdaConstant), U8(94),
- /* 1163 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1175 S> */ B(LdaConstant), U8(95),
- /* 1175 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1187 S> */ B(LdaConstant), U8(96),
- /* 1187 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1199 S> */ B(LdaConstant), U8(97),
- /* 1199 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1211 S> */ B(LdaConstant), U8(98),
- /* 1211 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1223 S> */ B(LdaConstant), U8(99),
- /* 1223 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1235 S> */ B(LdaConstant), U8(100),
- /* 1235 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1247 S> */ B(LdaConstant), U8(101),
- /* 1247 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1259 S> */ B(LdaConstant), U8(102),
- /* 1259 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1271 S> */ B(LdaConstant), U8(103),
- /* 1271 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1283 S> */ B(LdaConstant), U8(104),
- /* 1283 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1295 S> */ B(LdaConstant), U8(105),
- /* 1295 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1307 S> */ B(LdaConstant), U8(106),
- /* 1307 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1319 S> */ B(LdaConstant), U8(107),
- /* 1319 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1331 S> */ B(LdaConstant), U8(108),
- /* 1331 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1343 S> */ B(LdaConstant), U8(109),
- /* 1343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1355 S> */ B(LdaConstant), U8(110),
- /* 1355 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1367 S> */ B(LdaConstant), U8(111),
- /* 1367 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1379 S> */ B(LdaConstant), U8(112),
- /* 1379 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1391 S> */ B(LdaConstant), U8(113),
- /* 1391 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1403 S> */ B(LdaConstant), U8(114),
- /* 1403 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1415 S> */ B(LdaConstant), U8(115),
- /* 1415 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1427 S> */ B(LdaConstant), U8(116),
- /* 1427 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1439 S> */ B(LdaConstant), U8(117),
- /* 1439 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1451 S> */ B(LdaConstant), U8(118),
- /* 1451 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1463 S> */ B(LdaConstant), U8(119),
- /* 1463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1475 S> */ B(LdaConstant), U8(120),
- /* 1475 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1487 S> */ B(LdaConstant), U8(121),
- /* 1487 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1499 S> */ B(LdaConstant), U8(122),
- /* 1499 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1511 S> */ B(LdaConstant), U8(123),
- /* 1511 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1523 S> */ B(LdaConstant), U8(124),
- /* 1523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1535 S> */ B(LdaConstant), U8(125),
- /* 1535 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1547 S> */ B(LdaConstant), U8(126),
- /* 1547 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1559 S> */ B(LdaConstant), U8(127),
- /* 1559 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1571 S> */ B(LdaConstant), U8(128),
- /* 1571 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1583 S> */ B(LdaConstant), U8(129),
- /* 1583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1595 S> */ B(LdaConstant), U8(130),
- /* 1595 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1607 S> */ B(LdaConstant), U8(131),
- /* 1607 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1619 S> */ B(LdaConstant), U8(132),
- /* 1619 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1631 S> */ B(LdaConstant), U8(133),
- /* 1631 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1643 S> */ B(LdaConstant), U8(134),
- /* 1643 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1655 S> */ B(LdaConstant), U8(135),
- /* 1655 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1667 S> */ B(LdaConstant), U8(136),
- /* 1667 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1679 S> */ B(LdaConstant), U8(137),
- /* 1679 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1691 S> */ B(LdaConstant), U8(138),
- /* 1691 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1703 S> */ B(LdaConstant), U8(139),
- /* 1703 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1715 S> */ B(LdaConstant), U8(140),
- /* 1715 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1727 S> */ B(LdaConstant), U8(141),
- /* 1727 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1739 S> */ B(LdaConstant), U8(142),
- /* 1739 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1751 S> */ B(LdaConstant), U8(143),
- /* 1751 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1763 S> */ B(LdaConstant), U8(144),
- /* 1763 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1775 S> */ B(LdaConstant), U8(145),
- /* 1775 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1787 S> */ B(LdaConstant), U8(146),
- /* 1787 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1799 S> */ B(LdaConstant), U8(147),
- /* 1799 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1811 S> */ B(LdaConstant), U8(148),
- /* 1811 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1823 S> */ B(LdaConstant), U8(149),
- /* 1823 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1835 S> */ B(LdaConstant), U8(150),
- /* 1835 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1847 S> */ B(LdaConstant), U8(151),
- /* 1847 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1859 S> */ B(LdaConstant), U8(152),
- /* 1859 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1871 S> */ B(LdaConstant), U8(153),
- /* 1871 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1883 S> */ B(LdaConstant), U8(154),
- /* 1883 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1895 S> */ B(LdaConstant), U8(155),
- /* 1895 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1907 S> */ B(LdaConstant), U8(156),
- /* 1907 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1919 S> */ B(LdaConstant), U8(157),
- /* 1919 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1931 S> */ B(LdaConstant), U8(158),
- /* 1931 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1943 S> */ B(LdaConstant), U8(159),
- /* 1943 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1955 S> */ B(LdaConstant), U8(160),
- /* 1955 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1967 S> */ B(LdaConstant), U8(161),
- /* 1967 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1979 S> */ B(LdaConstant), U8(162),
- /* 1979 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1991 S> */ B(LdaConstant), U8(163),
- /* 1991 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2003 S> */ B(LdaConstant), U8(164),
- /* 2003 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2015 S> */ B(LdaConstant), U8(165),
- /* 2015 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2027 S> */ B(LdaConstant), U8(166),
- /* 2027 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2039 S> */ B(LdaConstant), U8(167),
- /* 2039 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2051 S> */ B(LdaConstant), U8(168),
- /* 2051 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2063 S> */ B(LdaConstant), U8(169),
- /* 2063 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2075 S> */ B(LdaConstant), U8(170),
- /* 2075 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2087 S> */ B(LdaConstant), U8(171),
- /* 2087 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2099 S> */ B(LdaConstant), U8(172),
- /* 2099 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2111 S> */ B(LdaConstant), U8(173),
- /* 2111 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2123 S> */ B(LdaConstant), U8(174),
- /* 2123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2135 S> */ B(LdaConstant), U8(175),
- /* 2135 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2147 S> */ B(LdaConstant), U8(176),
- /* 2147 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2159 S> */ B(LdaConstant), U8(177),
- /* 2159 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2171 S> */ B(LdaConstant), U8(178),
- /* 2171 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2183 S> */ B(LdaConstant), U8(179),
- /* 2183 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2195 S> */ B(LdaConstant), U8(180),
- /* 2195 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2207 S> */ B(LdaConstant), U8(181),
- /* 2207 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2219 S> */ B(LdaConstant), U8(182),
- /* 2219 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2231 S> */ B(LdaConstant), U8(183),
- /* 2231 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2243 S> */ B(LdaConstant), U8(184),
- /* 2243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2255 S> */ B(LdaConstant), U8(185),
- /* 2255 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2267 S> */ B(LdaConstant), U8(186),
- /* 2267 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2279 S> */ B(LdaConstant), U8(187),
- /* 2279 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2291 S> */ B(LdaConstant), U8(188),
- /* 2291 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2303 S> */ B(LdaConstant), U8(189),
- /* 2303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2315 S> */ B(LdaConstant), U8(190),
- /* 2315 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2327 S> */ B(LdaConstant), U8(191),
- /* 2327 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2339 S> */ B(LdaConstant), U8(192),
- /* 2339 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2351 S> */ B(LdaConstant), U8(193),
- /* 2351 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2363 S> */ B(LdaConstant), U8(194),
- /* 2363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2375 S> */ B(LdaConstant), U8(195),
- /* 2375 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2387 S> */ B(LdaConstant), U8(196),
- /* 2387 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2399 S> */ B(LdaConstant), U8(197),
- /* 2399 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2411 S> */ B(LdaConstant), U8(198),
- /* 2411 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2423 S> */ B(LdaConstant), U8(199),
- /* 2423 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2435 S> */ B(LdaConstant), U8(200),
- /* 2435 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2447 S> */ B(LdaConstant), U8(201),
- /* 2447 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2459 S> */ B(LdaConstant), U8(202),
- /* 2459 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2471 S> */ B(LdaConstant), U8(203),
- /* 2471 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2483 S> */ B(LdaConstant), U8(204),
- /* 2483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2495 S> */ B(LdaConstant), U8(205),
- /* 2495 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2507 S> */ B(LdaConstant), U8(206),
- /* 2507 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2519 S> */ B(LdaConstant), U8(207),
- /* 2519 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2531 S> */ B(LdaConstant), U8(208),
- /* 2531 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2543 S> */ B(LdaConstant), U8(209),
- /* 2543 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2555 S> */ B(LdaConstant), U8(210),
- /* 2555 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2567 S> */ B(LdaConstant), U8(211),
- /* 2567 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2579 S> */ B(LdaConstant), U8(212),
- /* 2579 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2591 S> */ B(LdaConstant), U8(213),
- /* 2591 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2603 S> */ B(LdaConstant), U8(214),
- /* 2603 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2615 S> */ B(LdaConstant), U8(215),
- /* 2615 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2627 S> */ B(LdaConstant), U8(216),
- /* 2627 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2639 S> */ B(LdaConstant), U8(217),
- /* 2639 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2651 S> */ B(LdaConstant), U8(218),
- /* 2651 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2663 S> */ B(LdaConstant), U8(219),
- /* 2663 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2675 S> */ B(LdaConstant), U8(220),
- /* 2675 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2687 S> */ B(LdaConstant), U8(221),
- /* 2687 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2699 S> */ B(LdaConstant), U8(222),
- /* 2699 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2711 S> */ B(LdaConstant), U8(223),
- /* 2711 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2723 S> */ B(LdaConstant), U8(224),
- /* 2723 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2735 S> */ B(LdaConstant), U8(225),
- /* 2735 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2747 S> */ B(LdaConstant), U8(226),
- /* 2747 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2759 S> */ B(LdaConstant), U8(227),
- /* 2759 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2771 S> */ B(LdaConstant), U8(228),
- /* 2771 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2783 S> */ B(LdaConstant), U8(229),
- /* 2783 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2795 S> */ B(LdaConstant), U8(230),
- /* 2795 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2807 S> */ B(LdaConstant), U8(231),
- /* 2807 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2819 S> */ B(LdaConstant), U8(232),
- /* 2819 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2831 S> */ B(LdaConstant), U8(233),
- /* 2831 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2843 S> */ B(LdaConstant), U8(234),
- /* 2843 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2855 S> */ B(LdaConstant), U8(235),
- /* 2855 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2867 S> */ B(LdaConstant), U8(236),
- /* 2867 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2879 S> */ B(LdaConstant), U8(237),
- /* 2879 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2891 S> */ B(LdaConstant), U8(238),
- /* 2891 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2903 S> */ B(LdaConstant), U8(239),
- /* 2903 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2915 S> */ B(LdaConstant), U8(240),
- /* 2915 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2927 S> */ B(LdaConstant), U8(241),
- /* 2927 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2939 S> */ B(LdaConstant), U8(242),
- /* 2939 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2951 S> */ B(LdaConstant), U8(243),
- /* 2951 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2963 S> */ B(LdaConstant), U8(244),
- /* 2963 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2975 S> */ B(LdaConstant), U8(245),
- /* 2975 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2987 S> */ B(LdaConstant), U8(246),
- /* 2987 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2999 S> */ B(LdaConstant), U8(247),
- /* 2999 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3011 S> */ B(LdaConstant), U8(248),
- /* 3011 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3023 S> */ B(LdaConstant), U8(249),
- /* 3023 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3035 S> */ B(LdaConstant), U8(250),
- /* 3035 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3047 S> */ B(LdaConstant), U8(251),
- /* 3047 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3059 S> */ B(LdaConstant), U8(252),
- /* 3059 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3071 S> */ B(LdaConstant), U8(253),
- /* 3071 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3083 S> */ B(LdaConstant), U8(254),
- /* 3083 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3095 S> */ B(LdaConstant), U8(255),
- /* 3095 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 3099 S> */ B(LdaSmi), U8(10),
/* 3101 E> */ B(Wide), B(StaLookupSlotStrict), U16(256),
B(LdaUndefined),
diff --git a/test/cctest/interpreter/bytecode_expectations/NewTarget.golden b/test/cctest/interpreter/bytecode_expectations/NewTarget.golden
index 08d2a13..398b857 100644
--- a/test/cctest/interpreter/bytecode_expectations/NewTarget.golden
+++ b/test/cctest/interpreter/bytecode_expectations/NewTarget.golden
@@ -13,12 +13,11 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 19
+bytecode array length: 18
bytecodes: [
- B(Ldar), R(new_target),
- B(Star), R(0),
+ B(Mov), R(new_target), R(0),
/* 30 E> */ B(StackCheck),
- /* 34 S> */ B(Ldar), R(0),
+ /* 34 S> */ B(Ldar), R(new_target),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(0),
B(Star), R(1),
@@ -37,12 +36,11 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 20
+bytecode array length: 19
bytecodes: [
- B(Ldar), R(new_target),
- B(Star), R(0),
+ B(Mov), R(new_target), R(0),
/* 30 E> */ B(StackCheck),
- /* 34 S> */ B(Ldar), R(0),
+ /* 34 S> */ B(Ldar), R(new_target),
B(JumpIfNotHole), U8(11),
B(LdaConstant), U8(0),
B(Star), R(1),
diff --git a/test/cctest/interpreter/bytecode_expectations/ObjectLiterals.golden b/test/cctest/interpreter/bytecode_expectations/ObjectLiterals.golden
index 831218d..2f4bd05 100644
--- a/test/cctest/interpreter/bytecode_expectations/ObjectLiterals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ObjectLiterals.golden
@@ -55,11 +55,11 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ 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(0),
+ /* 75 E> */ B(StaNamedPropertySloppy), R(1), U8(1), U8(1),
B(Ldar), R(1),
/* 80 S> */ B(Return),
]
@@ -74,20 +74,18 @@
snippet: "
var a = 1; return { val: a, val: a + 1 };
"
-frame size: 3
+frame size: 2
parameter count: 1
-bytecode array length: 26
+bytecode array length: 22
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ 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),
+ /* 67 E> */ B(Add), R(0),
+ B(StaNamedPropertySloppy), R(1), U8(1), U8(1),
B(Ldar), R(1),
/* 76 S> */ B(Return),
]
@@ -110,7 +108,7 @@
/* 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(StaNamedPropertySloppy), R(0), U8(2), U8(1),
B(Ldar), R(0),
/* 67 S> */ B(Return),
]
@@ -134,7 +132,7 @@
/* 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(StaNamedPropertySloppy), R(0), U8(2), U8(1),
B(Ldar), R(0),
/* 68 S> */ B(Return),
]
@@ -157,7 +155,6 @@
/* 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),
@@ -166,6 +163,7 @@
B(Star), R(4),
B(LdaZero),
B(Star), R(5),
+ B(Mov), R(0), R(1),
B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), R(1), U8(5),
B(Ldar), R(0),
/* 68 S> */ B(Return),
@@ -189,7 +187,6 @@
/* 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),
@@ -198,6 +195,7 @@
B(Star), R(4),
B(LdaZero),
B(Star), R(5),
+ B(Mov), R(0), R(1),
B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), R(1), U8(5),
B(Ldar), R(0),
/* 102 S> */ B(Return),
@@ -222,7 +220,6 @@
/* 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),
@@ -231,6 +228,7 @@
B(Star), R(4),
B(LdaZero),
B(Star), R(5),
+ B(Mov), R(0), R(1),
B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), R(1), U8(5),
B(Ldar), R(0),
/* 74 S> */ B(Return),
@@ -249,21 +247,20 @@
"
frame size: 6
parameter count: 1
-bytecode array length: 33
+bytecode array length: 32
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ 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(Mov), R(1), R(2),
+ B(Mov), R(0), R(4),
+ /* 57 E> */ B(CallRuntime), U16(Runtime::kSetProperty), R(2), U8(4),
B(Ldar), R(1),
/* 62 S> */ B(Return),
]
@@ -284,9 +281,9 @@
/* 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(Mov), R(0), R(1),
B(CallRuntime), U16(Runtime::kInternalSetPrototype), R(1), U8(2),
B(Ldar), R(0),
/* 62 S> */ B(Return),
@@ -307,12 +304,11 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
- /* 42 E> */ B(Star), R(0),
+ 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(Ldar), R(0),
+ /* 60 E> */ B(ToName),
B(Star), R(3),
B(LdaSmi), U8(1),
B(Star), R(4),
@@ -320,6 +316,7 @@
B(Star), R(5),
B(LdaZero),
B(Star), R(6),
+ B(Mov), R(1), R(2),
B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
B(Ldar), R(1),
/* 69 S> */ B(Return),
@@ -337,18 +334,16 @@
"
frame size: 7
parameter count: 1
-bytecode array length: 43
+bytecode array length: 41
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
- /* 42 E> */ B(Star), R(0),
+ 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(Ldar), R(0),
+ /* 64 E> */ B(StaNamedPropertySloppy), R(1), U8(2), U8(1),
+ /* 68 E> */ B(ToName),
B(Star), R(3),
B(LdaSmi), U8(1),
B(Star), R(4),
@@ -356,6 +351,7 @@
B(Star), R(5),
B(LdaZero),
B(Star), R(6),
+ B(Mov), R(1), R(2),
B(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
B(Ldar), R(1),
/* 77 S> */ B(Return),
@@ -374,16 +370,15 @@
"
frame size: 7
parameter count: 1
-bytecode array length: 53
+bytecode array length: 54
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
- /* 42 E> */ B(Star), R(0),
+ 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(Ldar), R(0),
+ /* 60 E> */ B(ToName),
B(Star), R(3),
B(LdaSmi), U8(1),
B(Star), R(4),
@@ -391,11 +386,12 @@
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(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
B(CreateObjectLiteral), U8(1), U8(0), U8(35),
B(Star), R(4),
- B(Star), R(3),
+ B(Mov), R(1), R(2),
+ B(Mov), R(4), R(3),
B(CallRuntime), U16(Runtime::kInternalSetPrototype), R(2), U8(2),
B(Ldar), R(1),
/* 84 S> */ B(Return),
@@ -417,12 +413,11 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
- /* 42 E> */ B(Star), R(0),
+ 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(Ldar), R(0),
+ /* 60 E> */ B(ToName),
B(Star), R(3),
B(LdaConstant), U8(2),
B(Star), R(4),
@@ -430,22 +425,23 @@
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(CallRuntime), U16(Runtime::kDefineDataPropertyInLiteral), R(2), U8(5),
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(CallRuntime), U16(Runtime::kDefineGetterPropertyUnchecked), R(2), U8(4),
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(Mov), R(1), R(2),
B(CallRuntime), U16(Runtime::kDefineSetterPropertyUnchecked), R(2), U8(4),
B(Ldar), R(1),
/* 99 S> */ B(Return),
diff --git a/test/cctest/interpreter/bytecode_expectations/ObjectLiteralsWide.golden b/test/cctest/interpreter/bytecode_expectations/ObjectLiteralsWide.golden
index 9f92943..144a3c5 100644
--- a/test/cctest/interpreter/bytecode_expectations/ObjectLiteralsWide.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ObjectLiteralsWide.golden
@@ -274,517 +274,517 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 41 S> */ B(LdaConstant), U8(0),
- /* 43 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 51 S> */ B(LdaConstant), U8(1),
- /* 53 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 61 S> */ B(LdaConstant), U8(2),
- /* 63 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 71 S> */ B(LdaConstant), U8(3),
- /* 73 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 81 S> */ B(LdaConstant), U8(4),
- /* 83 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 91 S> */ B(LdaConstant), U8(5),
- /* 93 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 101 S> */ B(LdaConstant), U8(6),
- /* 103 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 111 S> */ B(LdaConstant), U8(7),
- /* 113 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 121 S> */ B(LdaConstant), U8(8),
- /* 123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 131 S> */ B(LdaConstant), U8(9),
- /* 133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 141 S> */ B(LdaConstant), U8(10),
- /* 143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 151 S> */ B(LdaConstant), U8(11),
- /* 153 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 161 S> */ B(LdaConstant), U8(12),
- /* 163 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 171 S> */ B(LdaConstant), U8(13),
- /* 173 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 181 S> */ B(LdaConstant), U8(14),
- /* 183 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 191 S> */ B(LdaConstant), U8(15),
- /* 193 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 201 S> */ B(LdaConstant), U8(16),
- /* 203 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 211 S> */ B(LdaConstant), U8(17),
- /* 213 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 221 S> */ B(LdaConstant), U8(18),
- /* 223 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 231 S> */ B(LdaConstant), U8(19),
- /* 233 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 241 S> */ B(LdaConstant), U8(20),
- /* 243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 251 S> */ B(LdaConstant), U8(21),
- /* 253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 261 S> */ B(LdaConstant), U8(22),
- /* 263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 271 S> */ B(LdaConstant), U8(23),
- /* 273 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 281 S> */ B(LdaConstant), U8(24),
- /* 283 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 291 S> */ B(LdaConstant), U8(25),
- /* 293 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 301 S> */ B(LdaConstant), U8(26),
- /* 303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 311 S> */ B(LdaConstant), U8(27),
- /* 313 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 321 S> */ B(LdaConstant), U8(28),
- /* 323 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 331 S> */ B(LdaConstant), U8(29),
- /* 333 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 341 S> */ B(LdaConstant), U8(30),
- /* 343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 351 S> */ B(LdaConstant), U8(31),
- /* 353 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 361 S> */ B(LdaConstant), U8(32),
- /* 363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 371 S> */ B(LdaConstant), U8(33),
- /* 373 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 381 S> */ B(LdaConstant), U8(34),
- /* 383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 391 S> */ B(LdaConstant), U8(35),
- /* 393 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 401 S> */ B(LdaConstant), U8(36),
- /* 403 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 411 S> */ B(LdaConstant), U8(37),
- /* 413 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 421 S> */ B(LdaConstant), U8(38),
- /* 423 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 431 S> */ B(LdaConstant), U8(39),
- /* 433 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 441 S> */ B(LdaConstant), U8(40),
- /* 443 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 451 S> */ B(LdaConstant), U8(41),
- /* 453 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 461 S> */ B(LdaConstant), U8(42),
- /* 463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 471 S> */ B(LdaConstant), U8(43),
- /* 473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 481 S> */ B(LdaConstant), U8(44),
- /* 483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 491 S> */ B(LdaConstant), U8(45),
- /* 493 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 501 S> */ B(LdaConstant), U8(46),
- /* 503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 511 S> */ B(LdaConstant), U8(47),
- /* 513 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 521 S> */ B(LdaConstant), U8(48),
- /* 523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 531 S> */ B(LdaConstant), U8(49),
- /* 533 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 541 S> */ B(LdaConstant), U8(50),
- /* 543 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 551 S> */ B(LdaConstant), U8(51),
- /* 553 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 561 S> */ B(LdaConstant), U8(52),
- /* 563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 571 S> */ B(LdaConstant), U8(53),
- /* 573 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 581 S> */ B(LdaConstant), U8(54),
- /* 583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 591 S> */ B(LdaConstant), U8(55),
- /* 593 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 601 S> */ B(LdaConstant), U8(56),
- /* 603 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 611 S> */ B(LdaConstant), U8(57),
- /* 613 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 621 S> */ B(LdaConstant), U8(58),
- /* 623 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 631 S> */ B(LdaConstant), U8(59),
- /* 633 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 641 S> */ B(LdaConstant), U8(60),
- /* 643 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 651 S> */ B(LdaConstant), U8(61),
- /* 653 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 661 S> */ B(LdaConstant), U8(62),
- /* 663 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 671 S> */ B(LdaConstant), U8(63),
- /* 673 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 681 S> */ B(LdaConstant), U8(64),
- /* 683 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 691 S> */ B(LdaConstant), U8(65),
- /* 693 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 701 S> */ B(LdaConstant), U8(66),
- /* 703 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 711 S> */ B(LdaConstant), U8(67),
- /* 713 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 721 S> */ B(LdaConstant), U8(68),
- /* 723 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 731 S> */ B(LdaConstant), U8(69),
- /* 733 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 741 S> */ B(LdaConstant), U8(70),
- /* 743 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 751 S> */ B(LdaConstant), U8(71),
- /* 753 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 761 S> */ B(LdaConstant), U8(72),
- /* 763 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 771 S> */ B(LdaConstant), U8(73),
- /* 773 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 781 S> */ B(LdaConstant), U8(74),
- /* 783 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 791 S> */ B(LdaConstant), U8(75),
- /* 793 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 801 S> */ B(LdaConstant), U8(76),
- /* 803 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 811 S> */ B(LdaConstant), U8(77),
- /* 813 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 821 S> */ B(LdaConstant), U8(78),
- /* 823 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 831 S> */ B(LdaConstant), U8(79),
- /* 833 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 841 S> */ B(LdaConstant), U8(80),
- /* 843 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 851 S> */ B(LdaConstant), U8(81),
- /* 853 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 861 S> */ B(LdaConstant), U8(82),
- /* 863 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 871 S> */ B(LdaConstant), U8(83),
- /* 873 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 881 S> */ B(LdaConstant), U8(84),
- /* 883 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 891 S> */ B(LdaConstant), U8(85),
- /* 893 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 901 S> */ B(LdaConstant), U8(86),
- /* 903 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 911 S> */ B(LdaConstant), U8(87),
- /* 913 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 921 S> */ B(LdaConstant), U8(88),
- /* 923 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 931 S> */ B(LdaConstant), U8(89),
- /* 933 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 941 S> */ B(LdaConstant), U8(90),
- /* 943 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 951 S> */ B(LdaConstant), U8(91),
- /* 953 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 961 S> */ B(LdaConstant), U8(92),
- /* 963 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 971 S> */ B(LdaConstant), U8(93),
- /* 973 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 981 S> */ B(LdaConstant), U8(94),
- /* 983 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 991 S> */ B(LdaConstant), U8(95),
- /* 993 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1001 S> */ B(LdaConstant), U8(96),
- /* 1003 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1011 S> */ B(LdaConstant), U8(97),
- /* 1013 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1021 S> */ B(LdaConstant), U8(98),
- /* 1023 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1031 S> */ B(LdaConstant), U8(99),
- /* 1033 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1041 S> */ B(LdaConstant), U8(100),
- /* 1043 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1051 S> */ B(LdaConstant), U8(101),
- /* 1053 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1061 S> */ B(LdaConstant), U8(102),
- /* 1063 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1071 S> */ B(LdaConstant), U8(103),
- /* 1073 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1081 S> */ B(LdaConstant), U8(104),
- /* 1083 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1091 S> */ B(LdaConstant), U8(105),
- /* 1093 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1101 S> */ B(LdaConstant), U8(106),
- /* 1103 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1111 S> */ B(LdaConstant), U8(107),
- /* 1113 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1121 S> */ B(LdaConstant), U8(108),
- /* 1123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1131 S> */ B(LdaConstant), U8(109),
- /* 1133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1141 S> */ B(LdaConstant), U8(110),
- /* 1143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1151 S> */ B(LdaConstant), U8(111),
- /* 1153 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1161 S> */ B(LdaConstant), U8(112),
- /* 1163 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1171 S> */ B(LdaConstant), U8(113),
- /* 1173 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1181 S> */ B(LdaConstant), U8(114),
- /* 1183 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1191 S> */ B(LdaConstant), U8(115),
- /* 1193 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1201 S> */ B(LdaConstant), U8(116),
- /* 1203 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1211 S> */ B(LdaConstant), U8(117),
- /* 1213 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1221 S> */ B(LdaConstant), U8(118),
- /* 1223 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1231 S> */ B(LdaConstant), U8(119),
- /* 1233 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1241 S> */ B(LdaConstant), U8(120),
- /* 1243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1251 S> */ B(LdaConstant), U8(121),
- /* 1253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1261 S> */ B(LdaConstant), U8(122),
- /* 1263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1271 S> */ B(LdaConstant), U8(123),
- /* 1273 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1281 S> */ B(LdaConstant), U8(124),
- /* 1283 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1291 S> */ B(LdaConstant), U8(125),
- /* 1293 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1301 S> */ B(LdaConstant), U8(126),
- /* 1303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1311 S> */ B(LdaConstant), U8(127),
- /* 1313 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1321 S> */ B(LdaConstant), U8(128),
- /* 1323 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1331 S> */ B(LdaConstant), U8(129),
- /* 1333 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1341 S> */ B(LdaConstant), U8(130),
- /* 1343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1351 S> */ B(LdaConstant), U8(131),
- /* 1353 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1361 S> */ B(LdaConstant), U8(132),
- /* 1363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1371 S> */ B(LdaConstant), U8(133),
- /* 1373 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1381 S> */ B(LdaConstant), U8(134),
- /* 1383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1391 S> */ B(LdaConstant), U8(135),
- /* 1393 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1401 S> */ B(LdaConstant), U8(136),
- /* 1403 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1411 S> */ B(LdaConstant), U8(137),
- /* 1413 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1421 S> */ B(LdaConstant), U8(138),
- /* 1423 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1431 S> */ B(LdaConstant), U8(139),
- /* 1433 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1441 S> */ B(LdaConstant), U8(140),
- /* 1443 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1451 S> */ B(LdaConstant), U8(141),
- /* 1453 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1461 S> */ B(LdaConstant), U8(142),
- /* 1463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1471 S> */ B(LdaConstant), U8(143),
- /* 1473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1481 S> */ B(LdaConstant), U8(144),
- /* 1483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1491 S> */ B(LdaConstant), U8(145),
- /* 1493 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1501 S> */ B(LdaConstant), U8(146),
- /* 1503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1511 S> */ B(LdaConstant), U8(147),
- /* 1513 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1521 S> */ B(LdaConstant), U8(148),
- /* 1523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1531 S> */ B(LdaConstant), U8(149),
- /* 1533 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1541 S> */ B(LdaConstant), U8(150),
- /* 1543 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1551 S> */ B(LdaConstant), U8(151),
- /* 1553 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1561 S> */ B(LdaConstant), U8(152),
- /* 1563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1571 S> */ B(LdaConstant), U8(153),
- /* 1573 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1581 S> */ B(LdaConstant), U8(154),
- /* 1583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1591 S> */ B(LdaConstant), U8(155),
- /* 1593 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1601 S> */ B(LdaConstant), U8(156),
- /* 1603 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1611 S> */ B(LdaConstant), U8(157),
- /* 1613 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1621 S> */ B(LdaConstant), U8(158),
- /* 1623 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1631 S> */ B(LdaConstant), U8(159),
- /* 1633 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1641 S> */ B(LdaConstant), U8(160),
- /* 1643 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1651 S> */ B(LdaConstant), U8(161),
- /* 1653 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1661 S> */ B(LdaConstant), U8(162),
- /* 1663 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1671 S> */ B(LdaConstant), U8(163),
- /* 1673 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1681 S> */ B(LdaConstant), U8(164),
- /* 1683 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1691 S> */ B(LdaConstant), U8(165),
- /* 1693 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1701 S> */ B(LdaConstant), U8(166),
- /* 1703 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1711 S> */ B(LdaConstant), U8(167),
- /* 1713 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1721 S> */ B(LdaConstant), U8(168),
- /* 1723 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1731 S> */ B(LdaConstant), U8(169),
- /* 1733 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1741 S> */ B(LdaConstant), U8(170),
- /* 1743 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1751 S> */ B(LdaConstant), U8(171),
- /* 1753 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1761 S> */ B(LdaConstant), U8(172),
- /* 1763 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1771 S> */ B(LdaConstant), U8(173),
- /* 1773 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1781 S> */ B(LdaConstant), U8(174),
- /* 1783 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1791 S> */ B(LdaConstant), U8(175),
- /* 1793 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1801 S> */ B(LdaConstant), U8(176),
- /* 1803 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1811 S> */ B(LdaConstant), U8(177),
- /* 1813 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1821 S> */ B(LdaConstant), U8(178),
- /* 1823 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1831 S> */ B(LdaConstant), U8(179),
- /* 1833 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1841 S> */ B(LdaConstant), U8(180),
- /* 1843 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1851 S> */ B(LdaConstant), U8(181),
- /* 1853 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1861 S> */ B(LdaConstant), U8(182),
- /* 1863 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1871 S> */ B(LdaConstant), U8(183),
- /* 1873 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1881 S> */ B(LdaConstant), U8(184),
- /* 1883 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1891 S> */ B(LdaConstant), U8(185),
- /* 1893 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1901 S> */ B(LdaConstant), U8(186),
- /* 1903 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1911 S> */ B(LdaConstant), U8(187),
- /* 1913 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1921 S> */ B(LdaConstant), U8(188),
- /* 1923 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1931 S> */ B(LdaConstant), U8(189),
- /* 1933 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1941 S> */ B(LdaConstant), U8(190),
- /* 1943 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1951 S> */ B(LdaConstant), U8(191),
- /* 1953 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1961 S> */ B(LdaConstant), U8(192),
- /* 1963 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1971 S> */ B(LdaConstant), U8(193),
- /* 1973 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1981 S> */ B(LdaConstant), U8(194),
- /* 1983 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1991 S> */ B(LdaConstant), U8(195),
- /* 1993 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2001 S> */ B(LdaConstant), U8(196),
- /* 2003 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2011 S> */ B(LdaConstant), U8(197),
- /* 2013 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2021 S> */ B(LdaConstant), U8(198),
- /* 2023 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2031 S> */ B(LdaConstant), U8(199),
- /* 2033 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2041 S> */ B(LdaConstant), U8(200),
- /* 2043 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2051 S> */ B(LdaConstant), U8(201),
- /* 2053 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2061 S> */ B(LdaConstant), U8(202),
- /* 2063 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2071 S> */ B(LdaConstant), U8(203),
- /* 2073 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2081 S> */ B(LdaConstant), U8(204),
- /* 2083 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2091 S> */ B(LdaConstant), U8(205),
- /* 2093 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2101 S> */ B(LdaConstant), U8(206),
- /* 2103 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2111 S> */ B(LdaConstant), U8(207),
- /* 2113 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2121 S> */ B(LdaConstant), U8(208),
- /* 2123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2131 S> */ B(LdaConstant), U8(209),
- /* 2133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2141 S> */ B(LdaConstant), U8(210),
- /* 2143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2151 S> */ B(LdaConstant), U8(211),
- /* 2153 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2161 S> */ B(LdaConstant), U8(212),
- /* 2163 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2171 S> */ B(LdaConstant), U8(213),
- /* 2173 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2181 S> */ B(LdaConstant), U8(214),
- /* 2183 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2191 S> */ B(LdaConstant), U8(215),
- /* 2193 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2201 S> */ B(LdaConstant), U8(216),
- /* 2203 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2211 S> */ B(LdaConstant), U8(217),
- /* 2213 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2221 S> */ B(LdaConstant), U8(218),
- /* 2223 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2231 S> */ B(LdaConstant), U8(219),
- /* 2233 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2241 S> */ B(LdaConstant), U8(220),
- /* 2243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2251 S> */ B(LdaConstant), U8(221),
- /* 2253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2261 S> */ B(LdaConstant), U8(222),
- /* 2263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2271 S> */ B(LdaConstant), U8(223),
- /* 2273 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2281 S> */ B(LdaConstant), U8(224),
- /* 2283 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2291 S> */ B(LdaConstant), U8(225),
- /* 2293 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2301 S> */ B(LdaConstant), U8(226),
- /* 2303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2311 S> */ B(LdaConstant), U8(227),
- /* 2313 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2321 S> */ B(LdaConstant), U8(228),
- /* 2323 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2331 S> */ B(LdaConstant), U8(229),
- /* 2333 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2341 S> */ B(LdaConstant), U8(230),
- /* 2343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2351 S> */ B(LdaConstant), U8(231),
- /* 2353 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2361 S> */ B(LdaConstant), U8(232),
- /* 2363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2371 S> */ B(LdaConstant), U8(233),
- /* 2373 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2381 S> */ B(LdaConstant), U8(234),
- /* 2383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2391 S> */ B(LdaConstant), U8(235),
- /* 2393 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2401 S> */ B(LdaConstant), U8(236),
- /* 2403 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2411 S> */ B(LdaConstant), U8(237),
- /* 2413 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2421 S> */ B(LdaConstant), U8(238),
- /* 2423 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2431 S> */ B(LdaConstant), U8(239),
- /* 2433 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2441 S> */ B(LdaConstant), U8(240),
- /* 2443 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2451 S> */ B(LdaConstant), U8(241),
- /* 2453 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2461 S> */ B(LdaConstant), U8(242),
- /* 2463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2471 S> */ B(LdaConstant), U8(243),
- /* 2473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2481 S> */ B(LdaConstant), U8(244),
- /* 2483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2491 S> */ B(LdaConstant), U8(245),
- /* 2493 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2501 S> */ B(LdaConstant), U8(246),
- /* 2503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2511 S> */ B(LdaConstant), U8(247),
- /* 2513 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2521 S> */ B(LdaConstant), U8(248),
- /* 2523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2531 S> */ B(LdaConstant), U8(249),
- /* 2533 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2541 S> */ B(LdaConstant), U8(250),
- /* 2543 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2551 S> */ B(LdaConstant), U8(251),
- /* 2553 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2561 S> */ B(LdaConstant), U8(252),
- /* 2563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2571 S> */ B(LdaConstant), U8(253),
- /* 2573 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2581 S> */ B(LdaConstant), U8(254),
- /* 2583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2591 S> */ B(LdaConstant), U8(255),
- /* 2593 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2601 S> */ B(Wide), B(CreateObjectLiteral), U16(256), U16(0), U8(1),
B(Star), R(1),
/* 2638 S> */ B(Return),
diff --git a/test/cctest/interpreter/bytecode_expectations/OuterContextVariables.golden b/test/cctest/interpreter/bytecode_expectations/OuterContextVariables.golden
index af6e942..4478c4d 100644
--- a/test/cctest/interpreter/bytecode_expectations/OuterContextVariables.golden
+++ b/test/cctest/interpreter/bytecode_expectations/OuterContextVariables.golden
@@ -22,15 +22,11 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 21
+bytecode array length: 15
bytecodes: [
/* 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),
+ /* 102 S> */ B(LdrContextSlot), R(context), U8(1), R(0),
+ B(LdrContextSlot), R(0), U8(4), R(1),
/* 120 E> */ B(LdaContextSlot), R(context), U8(4),
B(Mul), R(1),
/* 130 S> */ B(Return),
@@ -54,15 +50,11 @@
"
frame size: 2
parameter count: 1
-bytecode array length: 22
+bytecode array length: 16
bytecodes: [
/* 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),
+ /* 102 S> */ B(LdrContextSlot), R(context), U8(4), R(0),
+ /* 111 E> */ B(LdrContextSlot), R(context), U8(1), R(1),
B(Ldar), R(0),
B(StaContextSlot), R(1), U8(4),
B(LdaUndefined),
diff --git a/test/cctest/interpreter/bytecode_expectations/Parameters.golden b/test/cctest/interpreter/bytecode_expectations/Parameters.golden
index f26c066..71b6df7 100644
--- a/test/cctest/interpreter/bytecode_expectations/Parameters.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Parameters.golden
@@ -109,7 +109,7 @@
bytecodes: [
/* 10 E> */ B(StackCheck),
/* 19 S> */ B(LdaSmi), U8(1),
- /* 24 E> */ B(Star), R(arg0),
+ B(Star), R(arg0),
B(LdaUndefined),
/* 29 S> */ B(Return),
]
@@ -129,7 +129,7 @@
bytecodes: [
/* 10 E> */ B(StackCheck),
/* 37 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(arg1),
+ B(Star), R(arg1),
B(LdaUndefined),
/* 47 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/PrimitiveExpressions.golden b/test/cctest/interpreter/bytecode_expectations/PrimitiveExpressions.golden
index b9fd679..8ff00a0 100644
--- a/test/cctest/interpreter/bytecode_expectations/PrimitiveExpressions.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PrimitiveExpressions.golden
@@ -13,11 +13,12 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 5
+bytecode array length: 6
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
+ /* 45 S> */ B(Nop),
/* 55 S> */ B(Return),
]
constant pool: [
@@ -29,16 +30,15 @@
snippet: "
var x = 0; return x + 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 11
+bytecode array length: 9
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(3),
+ B(Add), R(0),
/* 59 S> */ B(Return),
]
constant pool: [
@@ -50,16 +50,15 @@
snippet: "
var x = 0; return x - 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 11
+bytecode array length: 9
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(3),
+ B(Sub), R(0),
/* 59 S> */ B(Return),
]
constant pool: [
@@ -71,16 +70,15 @@
snippet: "
var x = 4; return x * 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(3),
+ B(Mul), R(0),
/* 59 S> */ B(Return),
]
constant pool: [
@@ -92,16 +90,15 @@
snippet: "
var x = 4; return x / 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(3),
+ B(Div), R(0),
/* 59 S> */ B(Return),
]
constant pool: [
@@ -113,16 +110,15 @@
snippet: "
var x = 4; return x % 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(3),
+ B(Mod), R(0),
/* 59 S> */ B(Return),
]
constant pool: [
@@ -134,16 +130,15 @@
snippet: "
var x = 1; return x | 2;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(2),
+ B(BitwiseOr), R(0),
/* 59 S> */ B(Return),
]
constant pool: [
@@ -155,16 +150,15 @@
snippet: "
var x = 1; return x ^ 2;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(2),
+ B(BitwiseXor), R(0),
/* 59 S> */ B(Return),
]
constant pool: [
@@ -176,16 +170,15 @@
snippet: "
var x = 1; return x & 2;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(2),
+ B(BitwiseAnd), R(0),
/* 59 S> */ B(Return),
]
constant pool: [
@@ -197,16 +190,15 @@
snippet: "
var x = 10; return x << 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 46 S> */ B(LdaSmi), U8(3),
+ B(ShiftLeft), R(0),
/* 61 S> */ B(Return),
]
constant pool: [
@@ -218,16 +210,15 @@
snippet: "
var x = 10; return x >> 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 46 S> */ B(LdaSmi), U8(3),
+ B(ShiftRight), R(0),
/* 61 S> */ B(Return),
]
constant pool: [
@@ -239,16 +230,15 @@
snippet: "
var x = 10; return x >>> 3;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 46 S> */ B(LdaSmi), U8(3),
+ B(ShiftRightLogical), R(0),
/* 62 S> */ B(Return),
]
constant pool: [
@@ -266,7 +256,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaZero),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(LdaSmi), U8(3),
/* 60 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/PropertyCall.golden b/test/cctest/interpreter/bytecode_expectations/PropertyCall.golden
index df4c277..583a073 100644
--- a/test/cctest/interpreter/bytecode_expectations/PropertyCall.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PropertyCall.golden
@@ -13,16 +13,14 @@
function f(a) { return a.func(); }
f(new (function Obj() { this.func = function() { return; }})())
"
-frame size: 2
+frame size: 1
parameter count: 2
-bytecode array length: 17
+bytecode array length: 13
bytecodes: [
/* 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),
+ /* 16 S> */ B(Nop),
+ /* 24 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(3), R(0),
+ /* 25 E> */ B(Call), R(0), R(arg0), U8(1), U8(1),
/* 33 S> */ B(Return),
]
constant pool: [
@@ -38,17 +36,15 @@
"
frame size: 4
parameter count: 4
-bytecode array length: 25
+bytecode array length: 24
bytecodes: [
/* 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),
+ /* 22 S> */ B(Nop),
+ /* 30 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(3), R(0),
+ B(Ldar), R(0),
+ B(Mov), R(arg0), R(1),
+ B(Mov), R(arg1), R(2),
+ B(Mov), R(arg2), R(3),
/* 31 E> */ B(Call), R(0), R(1), U8(3), U8(1),
/* 43 S> */ B(Return),
]
@@ -65,20 +61,16 @@
"
frame size: 4
parameter count: 3
-bytecode array length: 31
+bytecode array length: 25
bytecodes: [
/* 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),
+ /* 19 S> */ B(Nop),
+ /* 27 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(3), R(0),
+ B(Ldar), R(arg1),
+ /* 37 E> */ B(Add), R(arg1),
B(Star), R(2),
- /* 40 E> */ B(Ldar), R(arg1),
- B(Star), R(3),
+ B(Mov), R(arg0), R(1),
+ B(Mov), R(arg1), R(3),
/* 28 E> */ B(Call), R(0), R(1), U8(3), U8(1),
/* 44 S> */ B(Return),
]
@@ -222,400 +214,270 @@
return a.func(); }
f(new (function Obj() { this.func = function() { return; }})())
"
-frame size: 2
+frame size: 1
parameter count: 2
-bytecode array length: 1050
+bytecode array length: 663
bytecodes: [
/* 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),
+ /* 17 S> */ B(Nop),
+ /* 18 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(1),
+ /* 26 S> */ B(Nop),
+ /* 27 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(3),
+ /* 35 S> */ B(Nop),
+ /* 36 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(5),
+ /* 44 S> */ B(Nop),
+ /* 45 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(7),
+ /* 53 S> */ B(Nop),
+ /* 54 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(9),
+ /* 62 S> */ B(Nop),
+ /* 63 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(11),
+ /* 71 S> */ B(Nop),
+ /* 72 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(13),
+ /* 80 S> */ B(Nop),
+ /* 81 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(15),
+ /* 89 S> */ B(Nop),
+ /* 90 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(17),
+ /* 98 S> */ B(Nop),
+ /* 99 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(19),
+ /* 107 S> */ B(Nop),
+ /* 108 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(21),
+ /* 116 S> */ B(Nop),
+ /* 117 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(23),
+ /* 125 S> */ B(Nop),
+ /* 126 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(25),
+ /* 134 S> */ B(Nop),
+ /* 135 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(27),
+ /* 143 S> */ B(Nop),
+ /* 144 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(29),
+ /* 152 S> */ B(Nop),
+ /* 153 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(31),
+ /* 161 S> */ B(Nop),
+ /* 162 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(33),
+ /* 170 S> */ B(Nop),
+ /* 171 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(35),
+ /* 179 S> */ B(Nop),
+ /* 180 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(37),
+ /* 188 S> */ B(Nop),
+ /* 189 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(39),
+ /* 197 S> */ B(Nop),
+ /* 198 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(41),
+ /* 206 S> */ B(Nop),
+ /* 207 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(43),
+ /* 215 S> */ B(Nop),
+ /* 216 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(45),
+ /* 224 S> */ B(Nop),
+ /* 225 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(47),
+ /* 233 S> */ B(Nop),
+ /* 234 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(49),
+ /* 242 S> */ B(Nop),
+ /* 243 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(51),
+ /* 251 S> */ B(Nop),
+ /* 252 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(53),
+ /* 260 S> */ B(Nop),
+ /* 261 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(55),
+ /* 269 S> */ B(Nop),
+ /* 270 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(57),
+ /* 278 S> */ B(Nop),
+ /* 279 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(59),
+ /* 287 S> */ B(Nop),
+ /* 288 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(61),
+ /* 296 S> */ B(Nop),
+ /* 297 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(63),
+ /* 305 S> */ B(Nop),
+ /* 306 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(65),
+ /* 314 S> */ B(Nop),
+ /* 315 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(67),
+ /* 323 S> */ B(Nop),
+ /* 324 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(69),
+ /* 332 S> */ B(Nop),
+ /* 333 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(71),
+ /* 341 S> */ B(Nop),
+ /* 342 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(73),
+ /* 350 S> */ B(Nop),
+ /* 351 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(75),
+ /* 359 S> */ B(Nop),
+ /* 360 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(77),
+ /* 368 S> */ B(Nop),
+ /* 369 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(79),
+ /* 377 S> */ B(Nop),
+ /* 378 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(81),
+ /* 386 S> */ B(Nop),
+ /* 387 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(83),
+ /* 395 S> */ B(Nop),
+ /* 396 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(85),
+ /* 404 S> */ B(Nop),
+ /* 405 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(87),
+ /* 413 S> */ B(Nop),
+ /* 414 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(89),
+ /* 422 S> */ B(Nop),
+ /* 423 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(91),
+ /* 431 S> */ B(Nop),
+ /* 432 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(93),
+ /* 440 S> */ B(Nop),
+ /* 441 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(95),
+ /* 449 S> */ B(Nop),
+ /* 450 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(97),
+ /* 458 S> */ B(Nop),
+ /* 459 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(99),
+ /* 467 S> */ B(Nop),
+ /* 468 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(101),
+ /* 476 S> */ B(Nop),
+ /* 477 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(103),
+ /* 485 S> */ B(Nop),
+ /* 486 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(105),
+ /* 494 S> */ B(Nop),
+ /* 495 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(107),
+ /* 503 S> */ B(Nop),
+ /* 504 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(109),
+ /* 512 S> */ B(Nop),
+ /* 513 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(111),
+ /* 521 S> */ B(Nop),
+ /* 522 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(113),
+ /* 530 S> */ B(Nop),
+ /* 531 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(115),
+ /* 539 S> */ B(Nop),
+ /* 540 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(117),
+ /* 548 S> */ B(Nop),
+ /* 549 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(119),
+ /* 557 S> */ B(Nop),
+ /* 558 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(121),
+ /* 566 S> */ B(Nop),
+ /* 567 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(123),
+ /* 575 S> */ B(Nop),
+ /* 576 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(125),
+ /* 584 S> */ B(Nop),
+ /* 585 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(127),
+ /* 593 S> */ B(Nop),
+ /* 594 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(129),
+ /* 602 S> */ B(Nop),
+ /* 603 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(131),
+ /* 611 S> */ B(Nop),
+ /* 612 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(133),
+ /* 620 S> */ B(Nop),
+ /* 621 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(135),
+ /* 629 S> */ B(Nop),
+ /* 630 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(137),
+ /* 638 S> */ B(Nop),
+ /* 639 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(139),
+ /* 647 S> */ B(Nop),
+ /* 648 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(141),
+ /* 656 S> */ B(Nop),
+ /* 657 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(143),
+ /* 665 S> */ B(Nop),
+ /* 666 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(145),
+ /* 674 S> */ B(Nop),
+ /* 675 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(147),
+ /* 683 S> */ B(Nop),
+ /* 684 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(149),
+ /* 692 S> */ B(Nop),
+ /* 693 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(151),
+ /* 701 S> */ B(Nop),
+ /* 702 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(153),
+ /* 710 S> */ B(Nop),
+ /* 711 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(155),
+ /* 719 S> */ B(Nop),
+ /* 720 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(157),
+ /* 728 S> */ B(Nop),
+ /* 729 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(159),
+ /* 737 S> */ B(Nop),
+ /* 738 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(161),
+ /* 746 S> */ B(Nop),
+ /* 747 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(163),
+ /* 755 S> */ B(Nop),
+ /* 756 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(165),
+ /* 764 S> */ B(Nop),
+ /* 765 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(167),
+ /* 773 S> */ B(Nop),
+ /* 774 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(169),
+ /* 782 S> */ B(Nop),
+ /* 783 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(171),
+ /* 791 S> */ B(Nop),
+ /* 792 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(173),
+ /* 800 S> */ B(Nop),
+ /* 801 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(175),
+ /* 809 S> */ B(Nop),
+ /* 810 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(177),
+ /* 818 S> */ B(Nop),
+ /* 819 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(179),
+ /* 827 S> */ B(Nop),
+ /* 828 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(181),
+ /* 836 S> */ B(Nop),
+ /* 837 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(183),
+ /* 845 S> */ B(Nop),
+ /* 846 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(185),
+ /* 854 S> */ B(Nop),
+ /* 855 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(187),
+ /* 863 S> */ B(Nop),
+ /* 864 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(189),
+ /* 872 S> */ B(Nop),
+ /* 873 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(191),
+ /* 881 S> */ B(Nop),
+ /* 882 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(193),
+ /* 890 S> */ B(Nop),
+ /* 891 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(195),
+ /* 899 S> */ B(Nop),
+ /* 900 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(197),
+ /* 908 S> */ B(Nop),
+ /* 909 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(199),
+ /* 917 S> */ B(Nop),
+ /* 918 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(201),
+ /* 926 S> */ B(Nop),
+ /* 927 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(203),
+ /* 935 S> */ B(Nop),
+ /* 936 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(205),
+ /* 944 S> */ B(Nop),
+ /* 945 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(207),
+ /* 953 S> */ B(Nop),
+ /* 954 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(209),
+ /* 962 S> */ B(Nop),
+ /* 963 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(211),
+ /* 971 S> */ B(Nop),
+ /* 972 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(213),
+ /* 980 S> */ B(Nop),
+ /* 981 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(215),
+ /* 989 S> */ B(Nop),
+ /* 990 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(217),
+ /* 998 S> */ B(Nop),
+ /* 999 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(219),
+ /* 1007 S> */ B(Nop),
+ /* 1008 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(221),
+ /* 1016 S> */ B(Nop),
+ /* 1017 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(223),
+ /* 1025 S> */ B(Nop),
+ /* 1026 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(225),
+ /* 1034 S> */ B(Nop),
+ /* 1035 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(227),
+ /* 1043 S> */ B(Nop),
+ /* 1044 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(229),
+ /* 1052 S> */ B(Nop),
+ /* 1053 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(231),
+ /* 1061 S> */ B(Nop),
+ /* 1062 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(233),
+ /* 1070 S> */ B(Nop),
+ /* 1071 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(235),
+ /* 1079 S> */ B(Nop),
+ /* 1080 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(237),
+ /* 1088 S> */ B(Nop),
+ /* 1089 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(239),
+ /* 1097 S> */ B(Nop),
+ /* 1098 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(241),
+ /* 1106 S> */ B(Nop),
+ /* 1107 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(243),
+ /* 1115 S> */ B(Nop),
+ /* 1116 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(245),
+ /* 1124 S> */ B(Nop),
+ /* 1125 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(247),
+ /* 1133 S> */ B(Nop),
+ /* 1134 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(249),
+ /* 1142 S> */ B(Nop),
+ /* 1143 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(251),
+ /* 1151 S> */ B(Nop),
+ /* 1152 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(253),
+ /* 1160 S> */ B(Nop),
+ /* 1161 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(255),
+ /* 1169 S> */ B(Nop),
+ /* 1177 E> */ B(Wide), B(LdrNamedProperty), R16(arg0), U16(0), U16(259), R16(0),
+ /* 1178 E> */ B(Wide), B(Call), R16(0), R16(arg0), U16(1), U16(257),
/* 1186 S> */ B(Return),
]
constant pool: [
diff --git a/test/cctest/interpreter/bytecode_expectations/PropertyLoads.golden b/test/cctest/interpreter/bytecode_expectations/PropertyLoads.golden
index 76741cb..cee0357 100644
--- a/test/cctest/interpreter/bytecode_expectations/PropertyLoads.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PropertyLoads.golden
@@ -13,14 +13,13 @@
function f(a) { return a.name; }
f({name : \"test\"});
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 10
+bytecode array length: 7
bytecodes: [
/* 10 E> */ B(StackCheck),
- /* 16 S> */ B(Ldar), R(arg0),
- B(Star), R(0),
- /* 24 E> */ B(LoadIC), R(0), U8(0), U8(1),
+ /* 16 S> */ B(Nop),
+ /* 24 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(1),
/* 31 S> */ B(Return),
]
constant pool: [
@@ -34,14 +33,13 @@
function f(a) { return a[\"key\"]; }
f({key : \"test\"});
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 10
+bytecode array length: 7
bytecodes: [
/* 10 E> */ B(StackCheck),
- /* 16 S> */ B(Ldar), R(arg0),
- B(Star), R(0),
- /* 24 E> */ B(LoadIC), R(0), U8(0), U8(1),
+ /* 16 S> */ B(Nop),
+ /* 24 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(1),
/* 33 S> */ B(Return),
]
constant pool: [
@@ -55,15 +53,13 @@
function f(a) { return a[100]; }
f({100 : \"test\"});
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 11
+bytecode array length: 7
bytecodes: [
/* 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),
+ /* 16 S> */ B(LdaSmi), U8(100),
+ /* 24 E> */ B(LdaKeyedProperty), R(arg0), U8(1),
/* 31 S> */ B(Return),
]
constant pool: [
@@ -76,15 +72,13 @@
function f(a, b) { return a[b]; }
f({arg : \"test\"}, \"arg\");
"
-frame size: 1
+frame size: 0
parameter count: 3
-bytecode array length: 11
+bytecode array length: 7
bytecodes: [
/* 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),
+ /* 19 S> */ B(Ldar), R(arg1),
+ /* 28 E> */ B(LdaKeyedProperty), R(arg0), U8(1),
/* 32 S> */ B(Return),
]
constant pool: [
@@ -97,19 +91,16 @@
function f(a) { var b = a.name; return a[-124]; }
f({\"-124\" : \"test\", name : 123 })
"
-frame size: 2
+frame size: 1
parameter count: 2
-bytecode array length: 21
+bytecode array length: 15
bytecodes: [
/* 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),
+ /* 25 S> */ B(Nop),
+ /* 25 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(1), R(0),
+ B(Ldar), R(0),
+ /* 32 S> */ B(LdaSmi), U8(-124),
+ /* 40 E> */ B(LdaKeyedProperty), R(arg0), U8(3),
/* 48 S> */ B(Return),
]
constant pool: [
@@ -254,526 +245,397 @@
}
f({name : \"test\"})
"
-frame size: 2
+frame size: 1
parameter count: 2
-bytecode array length: 1294
+bytecode array length: 1035
bytecodes: [
/* 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),
+ /* 27 S> */ B(Nop),
+ /* 32 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(1), R(0),
+ B(Ldar), R(0),
+ /* 41 S> */ B(Nop),
+ /* 46 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(3), R(0),
+ B(Ldar), R(0),
+ /* 55 S> */ B(Nop),
+ /* 60 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(5), R(0),
+ B(Ldar), R(0),
+ /* 69 S> */ B(Nop),
+ /* 74 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(7), R(0),
+ B(Ldar), R(0),
+ /* 83 S> */ B(Nop),
+ /* 88 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(9), R(0),
+ B(Ldar), R(0),
+ /* 97 S> */ B(Nop),
+ /* 102 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(11), R(0),
+ B(Ldar), R(0),
+ /* 111 S> */ B(Nop),
+ /* 116 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(13), R(0),
+ B(Ldar), R(0),
+ /* 125 S> */ B(Nop),
+ /* 130 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(15), R(0),
+ B(Ldar), R(0),
+ /* 139 S> */ B(Nop),
+ /* 144 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(17), R(0),
+ B(Ldar), R(0),
+ /* 153 S> */ B(Nop),
+ /* 158 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(19), R(0),
+ B(Ldar), R(0),
+ /* 167 S> */ B(Nop),
+ /* 172 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(21), R(0),
+ B(Ldar), R(0),
+ /* 181 S> */ B(Nop),
+ /* 186 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(23), R(0),
+ B(Ldar), R(0),
+ /* 195 S> */ B(Nop),
+ /* 200 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(25), R(0),
+ B(Ldar), R(0),
+ /* 209 S> */ B(Nop),
+ /* 214 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(27), R(0),
+ B(Ldar), R(0),
+ /* 223 S> */ B(Nop),
+ /* 228 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(29), R(0),
+ B(Ldar), R(0),
+ /* 237 S> */ B(Nop),
+ /* 242 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(31), R(0),
+ B(Ldar), R(0),
+ /* 251 S> */ B(Nop),
+ /* 256 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(33), R(0),
+ B(Ldar), R(0),
+ /* 265 S> */ B(Nop),
+ /* 270 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(35), R(0),
+ B(Ldar), R(0),
+ /* 279 S> */ B(Nop),
+ /* 284 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(37), R(0),
+ B(Ldar), R(0),
+ /* 293 S> */ B(Nop),
+ /* 298 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(39), R(0),
+ B(Ldar), R(0),
+ /* 307 S> */ B(Nop),
+ /* 312 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(41), R(0),
+ B(Ldar), R(0),
+ /* 321 S> */ B(Nop),
+ /* 326 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(43), R(0),
+ B(Ldar), R(0),
+ /* 335 S> */ B(Nop),
+ /* 340 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(45), R(0),
+ B(Ldar), R(0),
+ /* 349 S> */ B(Nop),
+ /* 354 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(47), R(0),
+ B(Ldar), R(0),
+ /* 363 S> */ B(Nop),
+ /* 368 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(49), R(0),
+ B(Ldar), R(0),
+ /* 377 S> */ B(Nop),
+ /* 382 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(51), R(0),
+ B(Ldar), R(0),
+ /* 391 S> */ B(Nop),
+ /* 396 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(53), R(0),
+ B(Ldar), R(0),
+ /* 405 S> */ B(Nop),
+ /* 410 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(55), R(0),
+ B(Ldar), R(0),
+ /* 419 S> */ B(Nop),
+ /* 424 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(57), R(0),
+ B(Ldar), R(0),
+ /* 433 S> */ B(Nop),
+ /* 438 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(59), R(0),
+ B(Ldar), R(0),
+ /* 447 S> */ B(Nop),
+ /* 452 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(61), R(0),
+ B(Ldar), R(0),
+ /* 461 S> */ B(Nop),
+ /* 466 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(63), R(0),
+ B(Ldar), R(0),
+ /* 475 S> */ B(Nop),
+ /* 480 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(65), R(0),
+ B(Ldar), R(0),
+ /* 489 S> */ B(Nop),
+ /* 494 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(67), R(0),
+ B(Ldar), R(0),
+ /* 503 S> */ B(Nop),
+ /* 508 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(69), R(0),
+ B(Ldar), R(0),
+ /* 517 S> */ B(Nop),
+ /* 522 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(71), R(0),
+ B(Ldar), R(0),
+ /* 531 S> */ B(Nop),
+ /* 536 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(73), R(0),
+ B(Ldar), R(0),
+ /* 545 S> */ B(Nop),
+ /* 550 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(75), R(0),
+ B(Ldar), R(0),
+ /* 559 S> */ B(Nop),
+ /* 564 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(77), R(0),
+ B(Ldar), R(0),
+ /* 573 S> */ B(Nop),
+ /* 578 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(79), R(0),
+ B(Ldar), R(0),
+ /* 587 S> */ B(Nop),
+ /* 592 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(81), R(0),
+ B(Ldar), R(0),
+ /* 601 S> */ B(Nop),
+ /* 606 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(83), R(0),
+ B(Ldar), R(0),
+ /* 615 S> */ B(Nop),
+ /* 620 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(85), R(0),
+ B(Ldar), R(0),
+ /* 629 S> */ B(Nop),
+ /* 634 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(87), R(0),
+ B(Ldar), R(0),
+ /* 643 S> */ B(Nop),
+ /* 648 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(89), R(0),
+ B(Ldar), R(0),
+ /* 657 S> */ B(Nop),
+ /* 662 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(91), R(0),
+ B(Ldar), R(0),
+ /* 671 S> */ B(Nop),
+ /* 676 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(93), R(0),
+ B(Ldar), R(0),
+ /* 685 S> */ B(Nop),
+ /* 690 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(95), R(0),
+ B(Ldar), R(0),
+ /* 699 S> */ B(Nop),
+ /* 704 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(97), R(0),
+ B(Ldar), R(0),
+ /* 713 S> */ B(Nop),
+ /* 718 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(99), R(0),
+ B(Ldar), R(0),
+ /* 727 S> */ B(Nop),
+ /* 732 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(101), R(0),
+ B(Ldar), R(0),
+ /* 741 S> */ B(Nop),
+ /* 746 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(103), R(0),
+ B(Ldar), R(0),
+ /* 755 S> */ B(Nop),
+ /* 760 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(105), R(0),
+ B(Ldar), R(0),
+ /* 769 S> */ B(Nop),
+ /* 774 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(107), R(0),
+ B(Ldar), R(0),
+ /* 783 S> */ B(Nop),
+ /* 788 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(109), R(0),
+ B(Ldar), R(0),
+ /* 797 S> */ B(Nop),
+ /* 802 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(111), R(0),
+ B(Ldar), R(0),
+ /* 811 S> */ B(Nop),
+ /* 816 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(113), R(0),
+ B(Ldar), R(0),
+ /* 825 S> */ B(Nop),
+ /* 830 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(115), R(0),
+ B(Ldar), R(0),
+ /* 839 S> */ B(Nop),
+ /* 844 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(117), R(0),
+ B(Ldar), R(0),
+ /* 853 S> */ B(Nop),
+ /* 858 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(119), R(0),
+ B(Ldar), R(0),
+ /* 867 S> */ B(Nop),
+ /* 872 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(121), R(0),
+ B(Ldar), R(0),
+ /* 881 S> */ B(Nop),
+ /* 886 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(123), R(0),
+ B(Ldar), R(0),
+ /* 895 S> */ B(Nop),
+ /* 900 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(125), R(0),
+ B(Ldar), R(0),
+ /* 909 S> */ B(Nop),
+ /* 914 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(127), R(0),
+ B(Ldar), R(0),
+ /* 923 S> */ B(Nop),
+ /* 928 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(129), R(0),
+ B(Ldar), R(0),
+ /* 937 S> */ B(Nop),
+ /* 942 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(131), R(0),
+ B(Ldar), R(0),
+ /* 951 S> */ B(Nop),
+ /* 956 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(133), R(0),
+ B(Ldar), R(0),
+ /* 965 S> */ B(Nop),
+ /* 970 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(135), R(0),
+ B(Ldar), R(0),
+ /* 979 S> */ B(Nop),
+ /* 984 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(137), R(0),
+ B(Ldar), R(0),
+ /* 993 S> */ B(Nop),
+ /* 998 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(139), R(0),
+ B(Ldar), R(0),
+ /* 1007 S> */ B(Nop),
+ /* 1012 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(141), R(0),
+ B(Ldar), R(0),
+ /* 1021 S> */ B(Nop),
+ /* 1026 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(143), R(0),
+ B(Ldar), R(0),
+ /* 1035 S> */ B(Nop),
+ /* 1040 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(145), R(0),
+ B(Ldar), R(0),
+ /* 1049 S> */ B(Nop),
+ /* 1054 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(147), R(0),
+ B(Ldar), R(0),
+ /* 1063 S> */ B(Nop),
+ /* 1068 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(149), R(0),
+ B(Ldar), R(0),
+ /* 1077 S> */ B(Nop),
+ /* 1082 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(151), R(0),
+ B(Ldar), R(0),
+ /* 1091 S> */ B(Nop),
+ /* 1096 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(153), R(0),
+ B(Ldar), R(0),
+ /* 1105 S> */ B(Nop),
+ /* 1110 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(155), R(0),
+ B(Ldar), R(0),
+ /* 1119 S> */ B(Nop),
+ /* 1124 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(157), R(0),
+ B(Ldar), R(0),
+ /* 1133 S> */ B(Nop),
+ /* 1138 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(159), R(0),
+ B(Ldar), R(0),
+ /* 1147 S> */ B(Nop),
+ /* 1152 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(161), R(0),
+ B(Ldar), R(0),
+ /* 1161 S> */ B(Nop),
+ /* 1166 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(163), R(0),
+ B(Ldar), R(0),
+ /* 1175 S> */ B(Nop),
+ /* 1180 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(165), R(0),
+ B(Ldar), R(0),
+ /* 1189 S> */ B(Nop),
+ /* 1194 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(167), R(0),
+ B(Ldar), R(0),
+ /* 1203 S> */ B(Nop),
+ /* 1208 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(169), R(0),
+ B(Ldar), R(0),
+ /* 1217 S> */ B(Nop),
+ /* 1222 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(171), R(0),
+ B(Ldar), R(0),
+ /* 1231 S> */ B(Nop),
+ /* 1236 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(173), R(0),
+ B(Ldar), R(0),
+ /* 1245 S> */ B(Nop),
+ /* 1250 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(175), R(0),
+ B(Ldar), R(0),
+ /* 1259 S> */ B(Nop),
+ /* 1264 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(177), R(0),
+ B(Ldar), R(0),
+ /* 1273 S> */ B(Nop),
+ /* 1278 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(179), R(0),
+ B(Ldar), R(0),
+ /* 1287 S> */ B(Nop),
+ /* 1292 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(181), R(0),
+ B(Ldar), R(0),
+ /* 1301 S> */ B(Nop),
+ /* 1306 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(183), R(0),
+ B(Ldar), R(0),
+ /* 1315 S> */ B(Nop),
+ /* 1320 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(185), R(0),
+ B(Ldar), R(0),
+ /* 1329 S> */ B(Nop),
+ /* 1334 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(187), R(0),
+ B(Ldar), R(0),
+ /* 1343 S> */ B(Nop),
+ /* 1348 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(189), R(0),
+ B(Ldar), R(0),
+ /* 1357 S> */ B(Nop),
+ /* 1362 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(191), R(0),
+ B(Ldar), R(0),
+ /* 1371 S> */ B(Nop),
+ /* 1376 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(193), R(0),
+ B(Ldar), R(0),
+ /* 1385 S> */ B(Nop),
+ /* 1390 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(195), R(0),
+ B(Ldar), R(0),
+ /* 1399 S> */ B(Nop),
+ /* 1404 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(197), R(0),
+ B(Ldar), R(0),
+ /* 1413 S> */ B(Nop),
+ /* 1418 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(199), R(0),
+ B(Ldar), R(0),
+ /* 1427 S> */ B(Nop),
+ /* 1432 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(201), R(0),
+ B(Ldar), R(0),
+ /* 1441 S> */ B(Nop),
+ /* 1446 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(203), R(0),
+ B(Ldar), R(0),
+ /* 1455 S> */ B(Nop),
+ /* 1460 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(205), R(0),
+ B(Ldar), R(0),
+ /* 1469 S> */ B(Nop),
+ /* 1474 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(207), R(0),
+ B(Ldar), R(0),
+ /* 1483 S> */ B(Nop),
+ /* 1488 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(209), R(0),
+ B(Ldar), R(0),
+ /* 1497 S> */ B(Nop),
+ /* 1502 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(211), R(0),
+ B(Ldar), R(0),
+ /* 1511 S> */ B(Nop),
+ /* 1516 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(213), R(0),
+ B(Ldar), R(0),
+ /* 1525 S> */ B(Nop),
+ /* 1530 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(215), R(0),
+ B(Ldar), R(0),
+ /* 1539 S> */ B(Nop),
+ /* 1544 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(217), R(0),
+ B(Ldar), R(0),
+ /* 1553 S> */ B(Nop),
+ /* 1558 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(219), R(0),
+ B(Ldar), R(0),
+ /* 1567 S> */ B(Nop),
+ /* 1572 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(221), R(0),
+ B(Ldar), R(0),
+ /* 1581 S> */ B(Nop),
+ /* 1586 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(223), R(0),
+ B(Ldar), R(0),
+ /* 1595 S> */ B(Nop),
+ /* 1600 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(225), R(0),
+ B(Ldar), R(0),
+ /* 1609 S> */ B(Nop),
+ /* 1614 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(227), R(0),
+ B(Ldar), R(0),
+ /* 1623 S> */ B(Nop),
+ /* 1628 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(229), R(0),
+ B(Ldar), R(0),
+ /* 1637 S> */ B(Nop),
+ /* 1642 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(231), R(0),
+ B(Ldar), R(0),
+ /* 1651 S> */ B(Nop),
+ /* 1656 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(233), R(0),
+ B(Ldar), R(0),
+ /* 1665 S> */ B(Nop),
+ /* 1670 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(235), R(0),
+ B(Ldar), R(0),
+ /* 1679 S> */ B(Nop),
+ /* 1684 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(237), R(0),
+ B(Ldar), R(0),
+ /* 1693 S> */ B(Nop),
+ /* 1698 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(239), R(0),
+ B(Ldar), R(0),
+ /* 1707 S> */ B(Nop),
+ /* 1712 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(241), R(0),
+ B(Ldar), R(0),
+ /* 1721 S> */ B(Nop),
+ /* 1726 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(243), R(0),
+ B(Ldar), R(0),
+ /* 1735 S> */ B(Nop),
+ /* 1740 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(245), R(0),
+ B(Ldar), R(0),
+ /* 1749 S> */ B(Nop),
+ /* 1754 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(247), R(0),
+ B(Ldar), R(0),
+ /* 1763 S> */ B(Nop),
+ /* 1768 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(249), R(0),
+ B(Ldar), R(0),
+ /* 1777 S> */ B(Nop),
+ /* 1782 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(251), R(0),
+ B(Ldar), R(0),
+ /* 1791 S> */ B(Nop),
+ /* 1796 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(253), R(0),
+ B(Ldar), R(0),
+ /* 1805 S> */ B(Nop),
+ /* 1810 E> */ B(LdrNamedProperty), R(arg0), U8(0), U8(255), R(0),
+ B(Ldar), R(0),
+ /* 1819 S> */ B(Nop),
+ /* 1827 E> */ B(Wide), B(LdaNamedProperty), R16(arg0), U16(0), U16(257),
/* 1834 S> */ B(Return),
]
constant pool: [
@@ -918,655 +780,397 @@
}
f({name : \"test\"}, \"name\")
"
-frame size: 2
+frame size: 1
parameter count: 3
-bytecode array length: 1422
+bytecode array length: 1034
bytecodes: [
/* 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),
+ /* 30 S> */ B(Ldar), R(arg1),
+ /* 36 E> */ B(LdrKeyedProperty), R(arg0), U8(1), R(0),
+ B(Ldar), R(0),
+ /* 42 S> */ B(Ldar), R(arg1),
+ /* 48 E> */ B(LdrKeyedProperty), R(arg0), U8(3), R(0),
+ B(Ldar), R(0),
+ /* 54 S> */ B(Ldar), R(arg1),
+ /* 60 E> */ B(LdrKeyedProperty), R(arg0), U8(5), R(0),
+ B(Ldar), R(0),
+ /* 66 S> */ B(Ldar), R(arg1),
+ /* 72 E> */ B(LdrKeyedProperty), R(arg0), U8(7), R(0),
+ B(Ldar), R(0),
+ /* 78 S> */ B(Ldar), R(arg1),
+ /* 84 E> */ B(LdrKeyedProperty), R(arg0), U8(9), R(0),
+ B(Ldar), R(0),
+ /* 90 S> */ B(Ldar), R(arg1),
+ /* 96 E> */ B(LdrKeyedProperty), R(arg0), U8(11), R(0),
+ B(Ldar), R(0),
+ /* 102 S> */ B(Ldar), R(arg1),
+ /* 108 E> */ B(LdrKeyedProperty), R(arg0), U8(13), R(0),
+ B(Ldar), R(0),
+ /* 114 S> */ B(Ldar), R(arg1),
+ /* 120 E> */ B(LdrKeyedProperty), R(arg0), U8(15), R(0),
+ B(Ldar), R(0),
+ /* 126 S> */ B(Ldar), R(arg1),
+ /* 132 E> */ B(LdrKeyedProperty), R(arg0), U8(17), R(0),
+ B(Ldar), R(0),
+ /* 138 S> */ B(Ldar), R(arg1),
+ /* 144 E> */ B(LdrKeyedProperty), R(arg0), U8(19), R(0),
+ B(Ldar), R(0),
+ /* 150 S> */ B(Ldar), R(arg1),
+ /* 156 E> */ B(LdrKeyedProperty), R(arg0), U8(21), R(0),
+ B(Ldar), R(0),
+ /* 162 S> */ B(Ldar), R(arg1),
+ /* 168 E> */ B(LdrKeyedProperty), R(arg0), U8(23), R(0),
+ B(Ldar), R(0),
+ /* 174 S> */ B(Ldar), R(arg1),
+ /* 180 E> */ B(LdrKeyedProperty), R(arg0), U8(25), R(0),
+ B(Ldar), R(0),
+ /* 186 S> */ B(Ldar), R(arg1),
+ /* 192 E> */ B(LdrKeyedProperty), R(arg0), U8(27), R(0),
+ B(Ldar), R(0),
+ /* 198 S> */ B(Ldar), R(arg1),
+ /* 204 E> */ B(LdrKeyedProperty), R(arg0), U8(29), R(0),
+ B(Ldar), R(0),
+ /* 210 S> */ B(Ldar), R(arg1),
+ /* 216 E> */ B(LdrKeyedProperty), R(arg0), U8(31), R(0),
+ B(Ldar), R(0),
+ /* 222 S> */ B(Ldar), R(arg1),
+ /* 228 E> */ B(LdrKeyedProperty), R(arg0), U8(33), R(0),
+ B(Ldar), R(0),
+ /* 234 S> */ B(Ldar), R(arg1),
+ /* 240 E> */ B(LdrKeyedProperty), R(arg0), U8(35), R(0),
+ B(Ldar), R(0),
+ /* 246 S> */ B(Ldar), R(arg1),
+ /* 252 E> */ B(LdrKeyedProperty), R(arg0), U8(37), R(0),
+ B(Ldar), R(0),
+ /* 258 S> */ B(Ldar), R(arg1),
+ /* 264 E> */ B(LdrKeyedProperty), R(arg0), U8(39), R(0),
+ B(Ldar), R(0),
+ /* 270 S> */ B(Ldar), R(arg1),
+ /* 276 E> */ B(LdrKeyedProperty), R(arg0), U8(41), R(0),
+ B(Ldar), R(0),
+ /* 282 S> */ B(Ldar), R(arg1),
+ /* 288 E> */ B(LdrKeyedProperty), R(arg0), U8(43), R(0),
+ B(Ldar), R(0),
+ /* 294 S> */ B(Ldar), R(arg1),
+ /* 300 E> */ B(LdrKeyedProperty), R(arg0), U8(45), R(0),
+ B(Ldar), R(0),
+ /* 306 S> */ B(Ldar), R(arg1),
+ /* 312 E> */ B(LdrKeyedProperty), R(arg0), U8(47), R(0),
+ B(Ldar), R(0),
+ /* 318 S> */ B(Ldar), R(arg1),
+ /* 324 E> */ B(LdrKeyedProperty), R(arg0), U8(49), R(0),
+ B(Ldar), R(0),
+ /* 330 S> */ B(Ldar), R(arg1),
+ /* 336 E> */ B(LdrKeyedProperty), R(arg0), U8(51), R(0),
+ B(Ldar), R(0),
+ /* 342 S> */ B(Ldar), R(arg1),
+ /* 348 E> */ B(LdrKeyedProperty), R(arg0), U8(53), R(0),
+ B(Ldar), R(0),
+ /* 354 S> */ B(Ldar), R(arg1),
+ /* 360 E> */ B(LdrKeyedProperty), R(arg0), U8(55), R(0),
+ B(Ldar), R(0),
+ /* 366 S> */ B(Ldar), R(arg1),
+ /* 372 E> */ B(LdrKeyedProperty), R(arg0), U8(57), R(0),
+ B(Ldar), R(0),
+ /* 378 S> */ B(Ldar), R(arg1),
+ /* 384 E> */ B(LdrKeyedProperty), R(arg0), U8(59), R(0),
+ B(Ldar), R(0),
+ /* 390 S> */ B(Ldar), R(arg1),
+ /* 396 E> */ B(LdrKeyedProperty), R(arg0), U8(61), R(0),
+ B(Ldar), R(0),
+ /* 402 S> */ B(Ldar), R(arg1),
+ /* 408 E> */ B(LdrKeyedProperty), R(arg0), U8(63), R(0),
+ B(Ldar), R(0),
+ /* 414 S> */ B(Ldar), R(arg1),
+ /* 420 E> */ B(LdrKeyedProperty), R(arg0), U8(65), R(0),
+ B(Ldar), R(0),
+ /* 426 S> */ B(Ldar), R(arg1),
+ /* 432 E> */ B(LdrKeyedProperty), R(arg0), U8(67), R(0),
+ B(Ldar), R(0),
+ /* 438 S> */ B(Ldar), R(arg1),
+ /* 444 E> */ B(LdrKeyedProperty), R(arg0), U8(69), R(0),
+ B(Ldar), R(0),
+ /* 450 S> */ B(Ldar), R(arg1),
+ /* 456 E> */ B(LdrKeyedProperty), R(arg0), U8(71), R(0),
+ B(Ldar), R(0),
+ /* 462 S> */ B(Ldar), R(arg1),
+ /* 468 E> */ B(LdrKeyedProperty), R(arg0), U8(73), R(0),
+ B(Ldar), R(0),
+ /* 474 S> */ B(Ldar), R(arg1),
+ /* 480 E> */ B(LdrKeyedProperty), R(arg0), U8(75), R(0),
+ B(Ldar), R(0),
+ /* 486 S> */ B(Ldar), R(arg1),
+ /* 492 E> */ B(LdrKeyedProperty), R(arg0), U8(77), R(0),
+ B(Ldar), R(0),
+ /* 498 S> */ B(Ldar), R(arg1),
+ /* 504 E> */ B(LdrKeyedProperty), R(arg0), U8(79), R(0),
+ B(Ldar), R(0),
+ /* 510 S> */ B(Ldar), R(arg1),
+ /* 516 E> */ B(LdrKeyedProperty), R(arg0), U8(81), R(0),
+ B(Ldar), R(0),
+ /* 522 S> */ B(Ldar), R(arg1),
+ /* 528 E> */ B(LdrKeyedProperty), R(arg0), U8(83), R(0),
+ B(Ldar), R(0),
+ /* 534 S> */ B(Ldar), R(arg1),
+ /* 540 E> */ B(LdrKeyedProperty), R(arg0), U8(85), R(0),
+ B(Ldar), R(0),
+ /* 546 S> */ B(Ldar), R(arg1),
+ /* 552 E> */ B(LdrKeyedProperty), R(arg0), U8(87), R(0),
+ B(Ldar), R(0),
+ /* 558 S> */ B(Ldar), R(arg1),
+ /* 564 E> */ B(LdrKeyedProperty), R(arg0), U8(89), R(0),
+ B(Ldar), R(0),
+ /* 570 S> */ B(Ldar), R(arg1),
+ /* 576 E> */ B(LdrKeyedProperty), R(arg0), U8(91), R(0),
+ B(Ldar), R(0),
+ /* 582 S> */ B(Ldar), R(arg1),
+ /* 588 E> */ B(LdrKeyedProperty), R(arg0), U8(93), R(0),
+ B(Ldar), R(0),
+ /* 594 S> */ B(Ldar), R(arg1),
+ /* 600 E> */ B(LdrKeyedProperty), R(arg0), U8(95), R(0),
+ B(Ldar), R(0),
+ /* 606 S> */ B(Ldar), R(arg1),
+ /* 612 E> */ B(LdrKeyedProperty), R(arg0), U8(97), R(0),
+ B(Ldar), R(0),
+ /* 618 S> */ B(Ldar), R(arg1),
+ /* 624 E> */ B(LdrKeyedProperty), R(arg0), U8(99), R(0),
+ B(Ldar), R(0),
+ /* 630 S> */ B(Ldar), R(arg1),
+ /* 636 E> */ B(LdrKeyedProperty), R(arg0), U8(101), R(0),
+ B(Ldar), R(0),
+ /* 642 S> */ B(Ldar), R(arg1),
+ /* 648 E> */ B(LdrKeyedProperty), R(arg0), U8(103), R(0),
+ B(Ldar), R(0),
+ /* 654 S> */ B(Ldar), R(arg1),
+ /* 660 E> */ B(LdrKeyedProperty), R(arg0), U8(105), R(0),
+ B(Ldar), R(0),
+ /* 666 S> */ B(Ldar), R(arg1),
+ /* 672 E> */ B(LdrKeyedProperty), R(arg0), U8(107), R(0),
+ B(Ldar), R(0),
+ /* 678 S> */ B(Ldar), R(arg1),
+ /* 684 E> */ B(LdrKeyedProperty), R(arg0), U8(109), R(0),
+ B(Ldar), R(0),
+ /* 690 S> */ B(Ldar), R(arg1),
+ /* 696 E> */ B(LdrKeyedProperty), R(arg0), U8(111), R(0),
+ B(Ldar), R(0),
+ /* 702 S> */ B(Ldar), R(arg1),
+ /* 708 E> */ B(LdrKeyedProperty), R(arg0), U8(113), R(0),
+ B(Ldar), R(0),
+ /* 714 S> */ B(Ldar), R(arg1),
+ /* 720 E> */ B(LdrKeyedProperty), R(arg0), U8(115), R(0),
+ B(Ldar), R(0),
+ /* 726 S> */ B(Ldar), R(arg1),
+ /* 732 E> */ B(LdrKeyedProperty), R(arg0), U8(117), R(0),
+ B(Ldar), R(0),
+ /* 738 S> */ B(Ldar), R(arg1),
+ /* 744 E> */ B(LdrKeyedProperty), R(arg0), U8(119), R(0),
+ B(Ldar), R(0),
+ /* 750 S> */ B(Ldar), R(arg1),
+ /* 756 E> */ B(LdrKeyedProperty), R(arg0), U8(121), R(0),
+ B(Ldar), R(0),
+ /* 762 S> */ B(Ldar), R(arg1),
+ /* 768 E> */ B(LdrKeyedProperty), R(arg0), U8(123), R(0),
+ B(Ldar), R(0),
+ /* 774 S> */ B(Ldar), R(arg1),
+ /* 780 E> */ B(LdrKeyedProperty), R(arg0), U8(125), R(0),
+ B(Ldar), R(0),
+ /* 786 S> */ B(Ldar), R(arg1),
+ /* 792 E> */ B(LdrKeyedProperty), R(arg0), U8(127), R(0),
+ B(Ldar), R(0),
+ /* 798 S> */ B(Ldar), R(arg1),
+ /* 804 E> */ B(LdrKeyedProperty), R(arg0), U8(129), R(0),
+ B(Ldar), R(0),
+ /* 810 S> */ B(Ldar), R(arg1),
+ /* 816 E> */ B(LdrKeyedProperty), R(arg0), U8(131), R(0),
+ B(Ldar), R(0),
+ /* 822 S> */ B(Ldar), R(arg1),
+ /* 828 E> */ B(LdrKeyedProperty), R(arg0), U8(133), R(0),
+ B(Ldar), R(0),
+ /* 834 S> */ B(Ldar), R(arg1),
+ /* 840 E> */ B(LdrKeyedProperty), R(arg0), U8(135), R(0),
+ B(Ldar), R(0),
+ /* 846 S> */ B(Ldar), R(arg1),
+ /* 852 E> */ B(LdrKeyedProperty), R(arg0), U8(137), R(0),
+ B(Ldar), R(0),
+ /* 858 S> */ B(Ldar), R(arg1),
+ /* 864 E> */ B(LdrKeyedProperty), R(arg0), U8(139), R(0),
+ B(Ldar), R(0),
+ /* 870 S> */ B(Ldar), R(arg1),
+ /* 876 E> */ B(LdrKeyedProperty), R(arg0), U8(141), R(0),
+ B(Ldar), R(0),
+ /* 882 S> */ B(Ldar), R(arg1),
+ /* 888 E> */ B(LdrKeyedProperty), R(arg0), U8(143), R(0),
+ B(Ldar), R(0),
+ /* 894 S> */ B(Ldar), R(arg1),
+ /* 900 E> */ B(LdrKeyedProperty), R(arg0), U8(145), R(0),
+ B(Ldar), R(0),
+ /* 906 S> */ B(Ldar), R(arg1),
+ /* 912 E> */ B(LdrKeyedProperty), R(arg0), U8(147), R(0),
+ B(Ldar), R(0),
+ /* 918 S> */ B(Ldar), R(arg1),
+ /* 924 E> */ B(LdrKeyedProperty), R(arg0), U8(149), R(0),
+ B(Ldar), R(0),
+ /* 930 S> */ B(Ldar), R(arg1),
+ /* 936 E> */ B(LdrKeyedProperty), R(arg0), U8(151), R(0),
+ B(Ldar), R(0),
+ /* 942 S> */ B(Ldar), R(arg1),
+ /* 948 E> */ B(LdrKeyedProperty), R(arg0), U8(153), R(0),
+ B(Ldar), R(0),
+ /* 954 S> */ B(Ldar), R(arg1),
+ /* 960 E> */ B(LdrKeyedProperty), R(arg0), U8(155), R(0),
+ B(Ldar), R(0),
+ /* 966 S> */ B(Ldar), R(arg1),
+ /* 972 E> */ B(LdrKeyedProperty), R(arg0), U8(157), R(0),
+ B(Ldar), R(0),
+ /* 978 S> */ B(Ldar), R(arg1),
+ /* 984 E> */ B(LdrKeyedProperty), R(arg0), U8(159), R(0),
+ B(Ldar), R(0),
+ /* 990 S> */ B(Ldar), R(arg1),
+ /* 996 E> */ B(LdrKeyedProperty), R(arg0), U8(161), R(0),
+ B(Ldar), R(0),
+ /* 1002 S> */ B(Ldar), R(arg1),
+ /* 1008 E> */ B(LdrKeyedProperty), R(arg0), U8(163), R(0),
+ B(Ldar), R(0),
+ /* 1014 S> */ B(Ldar), R(arg1),
+ /* 1020 E> */ B(LdrKeyedProperty), R(arg0), U8(165), R(0),
+ B(Ldar), R(0),
+ /* 1026 S> */ B(Ldar), R(arg1),
+ /* 1032 E> */ B(LdrKeyedProperty), R(arg0), U8(167), R(0),
+ B(Ldar), R(0),
+ /* 1038 S> */ B(Ldar), R(arg1),
+ /* 1044 E> */ B(LdrKeyedProperty), R(arg0), U8(169), R(0),
+ B(Ldar), R(0),
+ /* 1050 S> */ B(Ldar), R(arg1),
+ /* 1056 E> */ B(LdrKeyedProperty), R(arg0), U8(171), R(0),
+ B(Ldar), R(0),
+ /* 1062 S> */ B(Ldar), R(arg1),
+ /* 1068 E> */ B(LdrKeyedProperty), R(arg0), U8(173), R(0),
+ B(Ldar), R(0),
+ /* 1074 S> */ B(Ldar), R(arg1),
+ /* 1080 E> */ B(LdrKeyedProperty), R(arg0), U8(175), R(0),
+ B(Ldar), R(0),
+ /* 1086 S> */ B(Ldar), R(arg1),
+ /* 1092 E> */ B(LdrKeyedProperty), R(arg0), U8(177), R(0),
+ B(Ldar), R(0),
+ /* 1098 S> */ B(Ldar), R(arg1),
+ /* 1104 E> */ B(LdrKeyedProperty), R(arg0), U8(179), R(0),
+ B(Ldar), R(0),
+ /* 1110 S> */ B(Ldar), R(arg1),
+ /* 1116 E> */ B(LdrKeyedProperty), R(arg0), U8(181), R(0),
+ B(Ldar), R(0),
+ /* 1122 S> */ B(Ldar), R(arg1),
+ /* 1128 E> */ B(LdrKeyedProperty), R(arg0), U8(183), R(0),
+ B(Ldar), R(0),
+ /* 1134 S> */ B(Ldar), R(arg1),
+ /* 1140 E> */ B(LdrKeyedProperty), R(arg0), U8(185), R(0),
+ B(Ldar), R(0),
+ /* 1146 S> */ B(Ldar), R(arg1),
+ /* 1152 E> */ B(LdrKeyedProperty), R(arg0), U8(187), R(0),
+ B(Ldar), R(0),
+ /* 1158 S> */ B(Ldar), R(arg1),
+ /* 1164 E> */ B(LdrKeyedProperty), R(arg0), U8(189), R(0),
+ B(Ldar), R(0),
+ /* 1170 S> */ B(Ldar), R(arg1),
+ /* 1176 E> */ B(LdrKeyedProperty), R(arg0), U8(191), R(0),
+ B(Ldar), R(0),
+ /* 1182 S> */ B(Ldar), R(arg1),
+ /* 1188 E> */ B(LdrKeyedProperty), R(arg0), U8(193), R(0),
+ B(Ldar), R(0),
+ /* 1194 S> */ B(Ldar), R(arg1),
+ /* 1200 E> */ B(LdrKeyedProperty), R(arg0), U8(195), R(0),
+ B(Ldar), R(0),
+ /* 1206 S> */ B(Ldar), R(arg1),
+ /* 1212 E> */ B(LdrKeyedProperty), R(arg0), U8(197), R(0),
+ B(Ldar), R(0),
+ /* 1218 S> */ B(Ldar), R(arg1),
+ /* 1224 E> */ B(LdrKeyedProperty), R(arg0), U8(199), R(0),
+ B(Ldar), R(0),
+ /* 1230 S> */ B(Ldar), R(arg1),
+ /* 1236 E> */ B(LdrKeyedProperty), R(arg0), U8(201), R(0),
+ B(Ldar), R(0),
+ /* 1242 S> */ B(Ldar), R(arg1),
+ /* 1248 E> */ B(LdrKeyedProperty), R(arg0), U8(203), R(0),
+ B(Ldar), R(0),
+ /* 1254 S> */ B(Ldar), R(arg1),
+ /* 1260 E> */ B(LdrKeyedProperty), R(arg0), U8(205), R(0),
+ B(Ldar), R(0),
+ /* 1266 S> */ B(Ldar), R(arg1),
+ /* 1272 E> */ B(LdrKeyedProperty), R(arg0), U8(207), R(0),
+ B(Ldar), R(0),
+ /* 1278 S> */ B(Ldar), R(arg1),
+ /* 1284 E> */ B(LdrKeyedProperty), R(arg0), U8(209), R(0),
+ B(Ldar), R(0),
+ /* 1290 S> */ B(Ldar), R(arg1),
+ /* 1296 E> */ B(LdrKeyedProperty), R(arg0), U8(211), R(0),
+ B(Ldar), R(0),
+ /* 1302 S> */ B(Ldar), R(arg1),
+ /* 1308 E> */ B(LdrKeyedProperty), R(arg0), U8(213), R(0),
+ B(Ldar), R(0),
+ /* 1314 S> */ B(Ldar), R(arg1),
+ /* 1320 E> */ B(LdrKeyedProperty), R(arg0), U8(215), R(0),
+ B(Ldar), R(0),
+ /* 1326 S> */ B(Ldar), R(arg1),
+ /* 1332 E> */ B(LdrKeyedProperty), R(arg0), U8(217), R(0),
+ B(Ldar), R(0),
+ /* 1338 S> */ B(Ldar), R(arg1),
+ /* 1344 E> */ B(LdrKeyedProperty), R(arg0), U8(219), R(0),
+ B(Ldar), R(0),
+ /* 1350 S> */ B(Ldar), R(arg1),
+ /* 1356 E> */ B(LdrKeyedProperty), R(arg0), U8(221), R(0),
+ B(Ldar), R(0),
+ /* 1362 S> */ B(Ldar), R(arg1),
+ /* 1368 E> */ B(LdrKeyedProperty), R(arg0), U8(223), R(0),
+ B(Ldar), R(0),
+ /* 1374 S> */ B(Ldar), R(arg1),
+ /* 1380 E> */ B(LdrKeyedProperty), R(arg0), U8(225), R(0),
+ B(Ldar), R(0),
+ /* 1386 S> */ B(Ldar), R(arg1),
+ /* 1392 E> */ B(LdrKeyedProperty), R(arg0), U8(227), R(0),
+ B(Ldar), R(0),
+ /* 1398 S> */ B(Ldar), R(arg1),
+ /* 1404 E> */ B(LdrKeyedProperty), R(arg0), U8(229), R(0),
+ B(Ldar), R(0),
+ /* 1410 S> */ B(Ldar), R(arg1),
+ /* 1416 E> */ B(LdrKeyedProperty), R(arg0), U8(231), R(0),
+ B(Ldar), R(0),
+ /* 1422 S> */ B(Ldar), R(arg1),
+ /* 1428 E> */ B(LdrKeyedProperty), R(arg0), U8(233), R(0),
+ B(Ldar), R(0),
+ /* 1434 S> */ B(Ldar), R(arg1),
+ /* 1440 E> */ B(LdrKeyedProperty), R(arg0), U8(235), R(0),
+ B(Ldar), R(0),
+ /* 1446 S> */ B(Ldar), R(arg1),
+ /* 1452 E> */ B(LdrKeyedProperty), R(arg0), U8(237), R(0),
+ B(Ldar), R(0),
+ /* 1458 S> */ B(Ldar), R(arg1),
+ /* 1464 E> */ B(LdrKeyedProperty), R(arg0), U8(239), R(0),
+ B(Ldar), R(0),
+ /* 1470 S> */ B(Ldar), R(arg1),
+ /* 1476 E> */ B(LdrKeyedProperty), R(arg0), U8(241), R(0),
+ B(Ldar), R(0),
+ /* 1482 S> */ B(Ldar), R(arg1),
+ /* 1488 E> */ B(LdrKeyedProperty), R(arg0), U8(243), R(0),
+ B(Ldar), R(0),
+ /* 1494 S> */ B(Ldar), R(arg1),
+ /* 1500 E> */ B(LdrKeyedProperty), R(arg0), U8(245), R(0),
+ B(Ldar), R(0),
+ /* 1506 S> */ B(Ldar), R(arg1),
+ /* 1512 E> */ B(LdrKeyedProperty), R(arg0), U8(247), R(0),
+ B(Ldar), R(0),
+ /* 1518 S> */ B(Ldar), R(arg1),
+ /* 1524 E> */ B(LdrKeyedProperty), R(arg0), U8(249), R(0),
+ B(Ldar), R(0),
+ /* 1530 S> */ B(Ldar), R(arg1),
+ /* 1536 E> */ B(LdrKeyedProperty), R(arg0), U8(251), R(0),
+ B(Ldar), R(0),
+ /* 1542 S> */ B(Ldar), R(arg1),
+ /* 1548 E> */ B(LdrKeyedProperty), R(arg0), U8(253), R(0),
+ B(Ldar), R(0),
+ /* 1554 S> */ B(Ldar), R(arg1),
+ /* 1560 E> */ B(LdrKeyedProperty), R(arg0), U8(255), R(0),
+ B(Ldar), R(0),
+ /* 1566 S> */ B(Ldar), R(arg1),
+ /* 1575 E> */ B(Wide), B(LdaKeyedProperty), R16(arg0), 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 340aa43..7f456cf 100644
--- a/test/cctest/interpreter/bytecode_expectations/PropertyStores.golden
+++ b/test/cctest/interpreter/bytecode_expectations/PropertyStores.golden
@@ -13,15 +13,13 @@
function f(a) { a.name = \"val\"; }
f({name : \"test\"})
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 13
+bytecode array length: 9
bytecodes: [
/* 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),
+ /* 16 S> */ B(LdaConstant), U8(0),
+ /* 23 E> */ B(StaNamedPropertySloppy), R(arg0), U8(1), U8(1),
B(LdaUndefined),
/* 32 S> */ B(Return),
]
@@ -37,15 +35,13 @@
function f(a) { a[\"key\"] = \"val\"; }
f({key : \"test\"})
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 13
+bytecode array length: 9
bytecodes: [
/* 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),
+ /* 16 S> */ B(LdaConstant), U8(0),
+ /* 25 E> */ B(StaNamedPropertySloppy), R(arg0), U8(1), U8(1),
B(LdaUndefined),
/* 34 S> */ B(Return),
]
@@ -63,15 +59,13 @@
"
frame size: 2
parameter count: 2
-bytecode array length: 17
+bytecode array length: 13
bytecodes: [
/* 10 E> */ B(StackCheck),
- /* 16 S> */ B(Ldar), R(arg0),
- B(Star), R(0),
- B(LdaSmi), U8(100),
+ /* 16 S> */ B(LdaSmi), U8(100),
B(Star), R(1),
B(LdaConstant), U8(0),
- /* 23 E> */ B(KeyedStoreICSloppy), R(0), R(1), U8(1),
+ /* 23 E> */ B(StaKeyedPropertySloppy), R(arg0), R(1), U8(1),
B(LdaUndefined),
/* 32 S> */ B(Return),
]
@@ -86,17 +80,13 @@
function f(a, b) { a[b] = \"val\"; }
f({arg : \"test\"}, \"arg\")
"
-frame size: 2
+frame size: 0
parameter count: 3
-bytecode array length: 17
+bytecode array length: 9
bytecodes: [
/* 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),
+ /* 19 S> */ B(LdaConstant), U8(0),
+ /* 24 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(1),
B(LdaUndefined),
/* 33 S> */ B(Return),
]
@@ -111,18 +101,14 @@
function f(a) { a.name = a[-124]; }
f({\"-124\" : \"test\", name : 123 })
"
-frame size: 2
+frame size: 0
parameter count: 2
-bytecode array length: 20
+bytecode array length: 12
bytecodes: [
/* 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),
+ /* 16 S> */ B(LdaSmi), U8(-124),
+ /* 26 E> */ B(LdaKeyedProperty), R(arg0), U8(1),
+ /* 23 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(3),
B(LdaUndefined),
/* 34 S> */ B(Return),
]
@@ -137,15 +123,13 @@
function f(a) { \"use strict\"; a.name = \"val\"; }
f({name : \"test\"})
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 13
+bytecode array length: 9
bytecodes: [
/* 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),
+ /* 30 S> */ B(LdaConstant), U8(0),
+ /* 37 E> */ B(StaNamedPropertyStrict), R(arg0), U8(1), U8(1),
B(LdaUndefined),
/* 46 S> */ B(Return),
]
@@ -161,17 +145,13 @@
function f(a, b) { \"use strict\"; a[b] = \"val\"; }
f({arg : \"test\"}, \"arg\")
"
-frame size: 2
+frame size: 0
parameter count: 3
-bytecode array length: 17
+bytecode array length: 9
bytecodes: [
/* 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),
+ /* 33 S> */ B(LdaConstant), U8(0),
+ /* 38 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(1),
B(LdaUndefined),
/* 47 S> */ B(Return),
]
@@ -316,527 +296,269 @@
}
f({name : \"test\"})
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 1297
+bytecode array length: 781
bytecodes: [
/* 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),
+ /* 18 S> */ B(LdaSmi), U8(1),
+ /* 25 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(1),
+ /* 32 S> */ B(LdaSmi), U8(1),
+ /* 39 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(3),
+ /* 46 S> */ B(LdaSmi), U8(1),
+ /* 53 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(5),
+ /* 60 S> */ B(LdaSmi), U8(1),
+ /* 67 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(7),
+ /* 74 S> */ B(LdaSmi), U8(1),
+ /* 81 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(9),
+ /* 88 S> */ B(LdaSmi), U8(1),
+ /* 95 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(11),
+ /* 102 S> */ B(LdaSmi), U8(1),
+ /* 109 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(13),
+ /* 116 S> */ B(LdaSmi), U8(1),
+ /* 123 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(15),
+ /* 130 S> */ B(LdaSmi), U8(1),
+ /* 137 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(17),
+ /* 144 S> */ B(LdaSmi), U8(1),
+ /* 151 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(19),
+ /* 158 S> */ B(LdaSmi), U8(1),
+ /* 165 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(21),
+ /* 172 S> */ B(LdaSmi), U8(1),
+ /* 179 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(23),
+ /* 186 S> */ B(LdaSmi), U8(1),
+ /* 193 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(25),
+ /* 200 S> */ B(LdaSmi), U8(1),
+ /* 207 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(27),
+ /* 214 S> */ B(LdaSmi), U8(1),
+ /* 221 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(29),
+ /* 228 S> */ B(LdaSmi), U8(1),
+ /* 235 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(31),
+ /* 242 S> */ B(LdaSmi), U8(1),
+ /* 249 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(33),
+ /* 256 S> */ B(LdaSmi), U8(1),
+ /* 263 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(35),
+ /* 270 S> */ B(LdaSmi), U8(1),
+ /* 277 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(37),
+ /* 284 S> */ B(LdaSmi), U8(1),
+ /* 291 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(39),
+ /* 298 S> */ B(LdaSmi), U8(1),
+ /* 305 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(41),
+ /* 312 S> */ B(LdaSmi), U8(1),
+ /* 319 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(43),
+ /* 326 S> */ B(LdaSmi), U8(1),
+ /* 333 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(45),
+ /* 340 S> */ B(LdaSmi), U8(1),
+ /* 347 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(47),
+ /* 354 S> */ B(LdaSmi), U8(1),
+ /* 361 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(49),
+ /* 368 S> */ B(LdaSmi), U8(1),
+ /* 375 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(51),
+ /* 382 S> */ B(LdaSmi), U8(1),
+ /* 389 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(53),
+ /* 396 S> */ B(LdaSmi), U8(1),
+ /* 403 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(55),
+ /* 410 S> */ B(LdaSmi), U8(1),
+ /* 417 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(57),
+ /* 424 S> */ B(LdaSmi), U8(1),
+ /* 431 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(59),
+ /* 438 S> */ B(LdaSmi), U8(1),
+ /* 445 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(61),
+ /* 452 S> */ B(LdaSmi), U8(1),
+ /* 459 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(63),
+ /* 466 S> */ B(LdaSmi), U8(1),
+ /* 473 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(65),
+ /* 480 S> */ B(LdaSmi), U8(1),
+ /* 487 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(67),
+ /* 494 S> */ B(LdaSmi), U8(1),
+ /* 501 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(69),
+ /* 508 S> */ B(LdaSmi), U8(1),
+ /* 515 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(71),
+ /* 522 S> */ B(LdaSmi), U8(1),
+ /* 529 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(73),
+ /* 536 S> */ B(LdaSmi), U8(1),
+ /* 543 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(75),
+ /* 550 S> */ B(LdaSmi), U8(1),
+ /* 557 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(77),
+ /* 564 S> */ B(LdaSmi), U8(1),
+ /* 571 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(79),
+ /* 578 S> */ B(LdaSmi), U8(1),
+ /* 585 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(81),
+ /* 592 S> */ B(LdaSmi), U8(1),
+ /* 599 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(83),
+ /* 606 S> */ B(LdaSmi), U8(1),
+ /* 613 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(85),
+ /* 620 S> */ B(LdaSmi), U8(1),
+ /* 627 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(87),
+ /* 634 S> */ B(LdaSmi), U8(1),
+ /* 641 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(89),
+ /* 648 S> */ B(LdaSmi), U8(1),
+ /* 655 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(91),
+ /* 662 S> */ B(LdaSmi), U8(1),
+ /* 669 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(93),
+ /* 676 S> */ B(LdaSmi), U8(1),
+ /* 683 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(95),
+ /* 690 S> */ B(LdaSmi), U8(1),
+ /* 697 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(97),
+ /* 704 S> */ B(LdaSmi), U8(1),
+ /* 711 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(99),
+ /* 718 S> */ B(LdaSmi), U8(1),
+ /* 725 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(101),
+ /* 732 S> */ B(LdaSmi), U8(1),
+ /* 739 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(103),
+ /* 746 S> */ B(LdaSmi), U8(1),
+ /* 753 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(105),
+ /* 760 S> */ B(LdaSmi), U8(1),
+ /* 767 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(107),
+ /* 774 S> */ B(LdaSmi), U8(1),
+ /* 781 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(109),
+ /* 788 S> */ B(LdaSmi), U8(1),
+ /* 795 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(111),
+ /* 802 S> */ B(LdaSmi), U8(1),
+ /* 809 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(113),
+ /* 816 S> */ B(LdaSmi), U8(1),
+ /* 823 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(115),
+ /* 830 S> */ B(LdaSmi), U8(1),
+ /* 837 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(117),
+ /* 844 S> */ B(LdaSmi), U8(1),
+ /* 851 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(119),
+ /* 858 S> */ B(LdaSmi), U8(1),
+ /* 865 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(121),
+ /* 872 S> */ B(LdaSmi), U8(1),
+ /* 879 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(123),
+ /* 886 S> */ B(LdaSmi), U8(1),
+ /* 893 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(125),
+ /* 900 S> */ B(LdaSmi), U8(1),
+ /* 907 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(127),
+ /* 914 S> */ B(LdaSmi), U8(1),
+ /* 921 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(129),
+ /* 928 S> */ B(LdaSmi), U8(1),
+ /* 935 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(131),
+ /* 942 S> */ B(LdaSmi), U8(1),
+ /* 949 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(133),
+ /* 956 S> */ B(LdaSmi), U8(1),
+ /* 963 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(135),
+ /* 970 S> */ B(LdaSmi), U8(1),
+ /* 977 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(137),
+ /* 984 S> */ B(LdaSmi), U8(1),
+ /* 991 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(139),
+ /* 998 S> */ B(LdaSmi), U8(1),
+ /* 1005 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(141),
+ /* 1012 S> */ B(LdaSmi), U8(1),
+ /* 1019 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(143),
+ /* 1026 S> */ B(LdaSmi), U8(1),
+ /* 1033 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(145),
+ /* 1040 S> */ B(LdaSmi), U8(1),
+ /* 1047 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(147),
+ /* 1054 S> */ B(LdaSmi), U8(1),
+ /* 1061 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(149),
+ /* 1068 S> */ B(LdaSmi), U8(1),
+ /* 1075 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(151),
+ /* 1082 S> */ B(LdaSmi), U8(1),
+ /* 1089 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(153),
+ /* 1096 S> */ B(LdaSmi), U8(1),
+ /* 1103 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(155),
+ /* 1110 S> */ B(LdaSmi), U8(1),
+ /* 1117 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(157),
+ /* 1124 S> */ B(LdaSmi), U8(1),
+ /* 1131 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(159),
+ /* 1138 S> */ B(LdaSmi), U8(1),
+ /* 1145 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(161),
+ /* 1152 S> */ B(LdaSmi), U8(1),
+ /* 1159 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(163),
+ /* 1166 S> */ B(LdaSmi), U8(1),
+ /* 1173 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(165),
+ /* 1180 S> */ B(LdaSmi), U8(1),
+ /* 1187 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(167),
+ /* 1194 S> */ B(LdaSmi), U8(1),
+ /* 1201 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(169),
+ /* 1208 S> */ B(LdaSmi), U8(1),
+ /* 1215 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(171),
+ /* 1222 S> */ B(LdaSmi), U8(1),
+ /* 1229 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(173),
+ /* 1236 S> */ B(LdaSmi), U8(1),
+ /* 1243 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(175),
+ /* 1250 S> */ B(LdaSmi), U8(1),
+ /* 1257 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(177),
+ /* 1264 S> */ B(LdaSmi), U8(1),
+ /* 1271 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(179),
+ /* 1278 S> */ B(LdaSmi), U8(1),
+ /* 1285 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(181),
+ /* 1292 S> */ B(LdaSmi), U8(1),
+ /* 1299 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(183),
+ /* 1306 S> */ B(LdaSmi), U8(1),
+ /* 1313 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(185),
+ /* 1320 S> */ B(LdaSmi), U8(1),
+ /* 1327 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(187),
+ /* 1334 S> */ B(LdaSmi), U8(1),
+ /* 1341 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(189),
+ /* 1348 S> */ B(LdaSmi), U8(1),
+ /* 1355 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(191),
+ /* 1362 S> */ B(LdaSmi), U8(1),
+ /* 1369 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(193),
+ /* 1376 S> */ B(LdaSmi), U8(1),
+ /* 1383 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(195),
+ /* 1390 S> */ B(LdaSmi), U8(1),
+ /* 1397 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(197),
+ /* 1404 S> */ B(LdaSmi), U8(1),
+ /* 1411 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(199),
+ /* 1418 S> */ B(LdaSmi), U8(1),
+ /* 1425 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(201),
+ /* 1432 S> */ B(LdaSmi), U8(1),
+ /* 1439 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(203),
+ /* 1446 S> */ B(LdaSmi), U8(1),
+ /* 1453 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(205),
+ /* 1460 S> */ B(LdaSmi), U8(1),
+ /* 1467 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(207),
+ /* 1474 S> */ B(LdaSmi), U8(1),
+ /* 1481 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(209),
+ /* 1488 S> */ B(LdaSmi), U8(1),
+ /* 1495 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(211),
+ /* 1502 S> */ B(LdaSmi), U8(1),
+ /* 1509 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(213),
+ /* 1516 S> */ B(LdaSmi), U8(1),
+ /* 1523 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(215),
+ /* 1530 S> */ B(LdaSmi), U8(1),
+ /* 1537 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(217),
+ /* 1544 S> */ B(LdaSmi), U8(1),
+ /* 1551 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(219),
+ /* 1558 S> */ B(LdaSmi), U8(1),
+ /* 1565 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(221),
+ /* 1572 S> */ B(LdaSmi), U8(1),
+ /* 1579 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(223),
+ /* 1586 S> */ B(LdaSmi), U8(1),
+ /* 1593 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(225),
+ /* 1600 S> */ B(LdaSmi), U8(1),
+ /* 1607 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(227),
+ /* 1614 S> */ B(LdaSmi), U8(1),
+ /* 1621 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(229),
+ /* 1628 S> */ B(LdaSmi), U8(1),
+ /* 1635 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(231),
+ /* 1642 S> */ B(LdaSmi), U8(1),
+ /* 1649 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(233),
+ /* 1656 S> */ B(LdaSmi), U8(1),
+ /* 1663 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(235),
+ /* 1670 S> */ B(LdaSmi), U8(1),
+ /* 1677 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(237),
+ /* 1684 S> */ B(LdaSmi), U8(1),
+ /* 1691 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(239),
+ /* 1698 S> */ B(LdaSmi), U8(1),
+ /* 1705 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(241),
+ /* 1712 S> */ B(LdaSmi), U8(1),
+ /* 1719 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(243),
+ /* 1726 S> */ B(LdaSmi), U8(1),
+ /* 1733 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(245),
+ /* 1740 S> */ B(LdaSmi), U8(1),
+ /* 1747 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(247),
+ /* 1754 S> */ B(LdaSmi), U8(1),
+ /* 1761 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(249),
+ /* 1768 S> */ B(LdaSmi), U8(1),
+ /* 1775 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(251),
+ /* 1782 S> */ B(LdaSmi), U8(1),
+ /* 1789 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(253),
+ /* 1796 S> */ B(LdaSmi), U8(1),
+ /* 1803 E> */ B(StaNamedPropertySloppy), R(arg0), U8(0), U8(255),
+ /* 1810 S> */ B(LdaSmi), U8(2),
+ /* 1817 E> */ B(Wide), B(StaNamedPropertySloppy), R16(arg0), U16(0), U16(257),
B(LdaUndefined),
/* 1822 S> */ B(Return),
]
@@ -982,527 +704,269 @@
}
f({name : \"test\"})
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 1297
+bytecode array length: 781
bytecodes: [
/* 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),
+ /* 33 S> */ B(LdaSmi), U8(1),
+ /* 40 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(1),
+ /* 47 S> */ B(LdaSmi), U8(1),
+ /* 54 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(3),
+ /* 61 S> */ B(LdaSmi), U8(1),
+ /* 68 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(5),
+ /* 75 S> */ B(LdaSmi), U8(1),
+ /* 82 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(7),
+ /* 89 S> */ B(LdaSmi), U8(1),
+ /* 96 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(9),
+ /* 103 S> */ B(LdaSmi), U8(1),
+ /* 110 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(11),
+ /* 117 S> */ B(LdaSmi), U8(1),
+ /* 124 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(13),
+ /* 131 S> */ B(LdaSmi), U8(1),
+ /* 138 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(15),
+ /* 145 S> */ B(LdaSmi), U8(1),
+ /* 152 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(17),
+ /* 159 S> */ B(LdaSmi), U8(1),
+ /* 166 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(19),
+ /* 173 S> */ B(LdaSmi), U8(1),
+ /* 180 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(21),
+ /* 187 S> */ B(LdaSmi), U8(1),
+ /* 194 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(23),
+ /* 201 S> */ B(LdaSmi), U8(1),
+ /* 208 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(25),
+ /* 215 S> */ B(LdaSmi), U8(1),
+ /* 222 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(27),
+ /* 229 S> */ B(LdaSmi), U8(1),
+ /* 236 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(29),
+ /* 243 S> */ B(LdaSmi), U8(1),
+ /* 250 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(31),
+ /* 257 S> */ B(LdaSmi), U8(1),
+ /* 264 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(33),
+ /* 271 S> */ B(LdaSmi), U8(1),
+ /* 278 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(35),
+ /* 285 S> */ B(LdaSmi), U8(1),
+ /* 292 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(37),
+ /* 299 S> */ B(LdaSmi), U8(1),
+ /* 306 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(39),
+ /* 313 S> */ B(LdaSmi), U8(1),
+ /* 320 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(41),
+ /* 327 S> */ B(LdaSmi), U8(1),
+ /* 334 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(43),
+ /* 341 S> */ B(LdaSmi), U8(1),
+ /* 348 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(45),
+ /* 355 S> */ B(LdaSmi), U8(1),
+ /* 362 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(47),
+ /* 369 S> */ B(LdaSmi), U8(1),
+ /* 376 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(49),
+ /* 383 S> */ B(LdaSmi), U8(1),
+ /* 390 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(51),
+ /* 397 S> */ B(LdaSmi), U8(1),
+ /* 404 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(53),
+ /* 411 S> */ B(LdaSmi), U8(1),
+ /* 418 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(55),
+ /* 425 S> */ B(LdaSmi), U8(1),
+ /* 432 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(57),
+ /* 439 S> */ B(LdaSmi), U8(1),
+ /* 446 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(59),
+ /* 453 S> */ B(LdaSmi), U8(1),
+ /* 460 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(61),
+ /* 467 S> */ B(LdaSmi), U8(1),
+ /* 474 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(63),
+ /* 481 S> */ B(LdaSmi), U8(1),
+ /* 488 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(65),
+ /* 495 S> */ B(LdaSmi), U8(1),
+ /* 502 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(67),
+ /* 509 S> */ B(LdaSmi), U8(1),
+ /* 516 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(69),
+ /* 523 S> */ B(LdaSmi), U8(1),
+ /* 530 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(71),
+ /* 537 S> */ B(LdaSmi), U8(1),
+ /* 544 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(73),
+ /* 551 S> */ B(LdaSmi), U8(1),
+ /* 558 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(75),
+ /* 565 S> */ B(LdaSmi), U8(1),
+ /* 572 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(77),
+ /* 579 S> */ B(LdaSmi), U8(1),
+ /* 586 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(79),
+ /* 593 S> */ B(LdaSmi), U8(1),
+ /* 600 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(81),
+ /* 607 S> */ B(LdaSmi), U8(1),
+ /* 614 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(83),
+ /* 621 S> */ B(LdaSmi), U8(1),
+ /* 628 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(85),
+ /* 635 S> */ B(LdaSmi), U8(1),
+ /* 642 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(87),
+ /* 649 S> */ B(LdaSmi), U8(1),
+ /* 656 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(89),
+ /* 663 S> */ B(LdaSmi), U8(1),
+ /* 670 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(91),
+ /* 677 S> */ B(LdaSmi), U8(1),
+ /* 684 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(93),
+ /* 691 S> */ B(LdaSmi), U8(1),
+ /* 698 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(95),
+ /* 705 S> */ B(LdaSmi), U8(1),
+ /* 712 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(97),
+ /* 719 S> */ B(LdaSmi), U8(1),
+ /* 726 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(99),
+ /* 733 S> */ B(LdaSmi), U8(1),
+ /* 740 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(101),
+ /* 747 S> */ B(LdaSmi), U8(1),
+ /* 754 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(103),
+ /* 761 S> */ B(LdaSmi), U8(1),
+ /* 768 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(105),
+ /* 775 S> */ B(LdaSmi), U8(1),
+ /* 782 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(107),
+ /* 789 S> */ B(LdaSmi), U8(1),
+ /* 796 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(109),
+ /* 803 S> */ B(LdaSmi), U8(1),
+ /* 810 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(111),
+ /* 817 S> */ B(LdaSmi), U8(1),
+ /* 824 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(113),
+ /* 831 S> */ B(LdaSmi), U8(1),
+ /* 838 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(115),
+ /* 845 S> */ B(LdaSmi), U8(1),
+ /* 852 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(117),
+ /* 859 S> */ B(LdaSmi), U8(1),
+ /* 866 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(119),
+ /* 873 S> */ B(LdaSmi), U8(1),
+ /* 880 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(121),
+ /* 887 S> */ B(LdaSmi), U8(1),
+ /* 894 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(123),
+ /* 901 S> */ B(LdaSmi), U8(1),
+ /* 908 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(125),
+ /* 915 S> */ B(LdaSmi), U8(1),
+ /* 922 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(127),
+ /* 929 S> */ B(LdaSmi), U8(1),
+ /* 936 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(129),
+ /* 943 S> */ B(LdaSmi), U8(1),
+ /* 950 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(131),
+ /* 957 S> */ B(LdaSmi), U8(1),
+ /* 964 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(133),
+ /* 971 S> */ B(LdaSmi), U8(1),
+ /* 978 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(135),
+ /* 985 S> */ B(LdaSmi), U8(1),
+ /* 992 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(137),
+ /* 999 S> */ B(LdaSmi), U8(1),
+ /* 1006 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(139),
+ /* 1013 S> */ B(LdaSmi), U8(1),
+ /* 1020 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(141),
+ /* 1027 S> */ B(LdaSmi), U8(1),
+ /* 1034 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(143),
+ /* 1041 S> */ B(LdaSmi), U8(1),
+ /* 1048 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(145),
+ /* 1055 S> */ B(LdaSmi), U8(1),
+ /* 1062 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(147),
+ /* 1069 S> */ B(LdaSmi), U8(1),
+ /* 1076 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(149),
+ /* 1083 S> */ B(LdaSmi), U8(1),
+ /* 1090 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(151),
+ /* 1097 S> */ B(LdaSmi), U8(1),
+ /* 1104 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(153),
+ /* 1111 S> */ B(LdaSmi), U8(1),
+ /* 1118 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(155),
+ /* 1125 S> */ B(LdaSmi), U8(1),
+ /* 1132 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(157),
+ /* 1139 S> */ B(LdaSmi), U8(1),
+ /* 1146 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(159),
+ /* 1153 S> */ B(LdaSmi), U8(1),
+ /* 1160 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(161),
+ /* 1167 S> */ B(LdaSmi), U8(1),
+ /* 1174 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(163),
+ /* 1181 S> */ B(LdaSmi), U8(1),
+ /* 1188 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(165),
+ /* 1195 S> */ B(LdaSmi), U8(1),
+ /* 1202 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(167),
+ /* 1209 S> */ B(LdaSmi), U8(1),
+ /* 1216 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(169),
+ /* 1223 S> */ B(LdaSmi), U8(1),
+ /* 1230 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(171),
+ /* 1237 S> */ B(LdaSmi), U8(1),
+ /* 1244 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(173),
+ /* 1251 S> */ B(LdaSmi), U8(1),
+ /* 1258 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(175),
+ /* 1265 S> */ B(LdaSmi), U8(1),
+ /* 1272 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(177),
+ /* 1279 S> */ B(LdaSmi), U8(1),
+ /* 1286 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(179),
+ /* 1293 S> */ B(LdaSmi), U8(1),
+ /* 1300 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(181),
+ /* 1307 S> */ B(LdaSmi), U8(1),
+ /* 1314 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(183),
+ /* 1321 S> */ B(LdaSmi), U8(1),
+ /* 1328 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(185),
+ /* 1335 S> */ B(LdaSmi), U8(1),
+ /* 1342 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(187),
+ /* 1349 S> */ B(LdaSmi), U8(1),
+ /* 1356 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(189),
+ /* 1363 S> */ B(LdaSmi), U8(1),
+ /* 1370 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(191),
+ /* 1377 S> */ B(LdaSmi), U8(1),
+ /* 1384 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(193),
+ /* 1391 S> */ B(LdaSmi), U8(1),
+ /* 1398 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(195),
+ /* 1405 S> */ B(LdaSmi), U8(1),
+ /* 1412 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(197),
+ /* 1419 S> */ B(LdaSmi), U8(1),
+ /* 1426 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(199),
+ /* 1433 S> */ B(LdaSmi), U8(1),
+ /* 1440 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(201),
+ /* 1447 S> */ B(LdaSmi), U8(1),
+ /* 1454 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(203),
+ /* 1461 S> */ B(LdaSmi), U8(1),
+ /* 1468 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(205),
+ /* 1475 S> */ B(LdaSmi), U8(1),
+ /* 1482 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(207),
+ /* 1489 S> */ B(LdaSmi), U8(1),
+ /* 1496 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(209),
+ /* 1503 S> */ B(LdaSmi), U8(1),
+ /* 1510 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(211),
+ /* 1517 S> */ B(LdaSmi), U8(1),
+ /* 1524 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(213),
+ /* 1531 S> */ B(LdaSmi), U8(1),
+ /* 1538 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(215),
+ /* 1545 S> */ B(LdaSmi), U8(1),
+ /* 1552 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(217),
+ /* 1559 S> */ B(LdaSmi), U8(1),
+ /* 1566 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(219),
+ /* 1573 S> */ B(LdaSmi), U8(1),
+ /* 1580 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(221),
+ /* 1587 S> */ B(LdaSmi), U8(1),
+ /* 1594 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(223),
+ /* 1601 S> */ B(LdaSmi), U8(1),
+ /* 1608 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(225),
+ /* 1615 S> */ B(LdaSmi), U8(1),
+ /* 1622 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(227),
+ /* 1629 S> */ B(LdaSmi), U8(1),
+ /* 1636 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(229),
+ /* 1643 S> */ B(LdaSmi), U8(1),
+ /* 1650 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(231),
+ /* 1657 S> */ B(LdaSmi), U8(1),
+ /* 1664 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(233),
+ /* 1671 S> */ B(LdaSmi), U8(1),
+ /* 1678 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(235),
+ /* 1685 S> */ B(LdaSmi), U8(1),
+ /* 1692 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(237),
+ /* 1699 S> */ B(LdaSmi), U8(1),
+ /* 1706 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(239),
+ /* 1713 S> */ B(LdaSmi), U8(1),
+ /* 1720 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(241),
+ /* 1727 S> */ B(LdaSmi), U8(1),
+ /* 1734 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(243),
+ /* 1741 S> */ B(LdaSmi), U8(1),
+ /* 1748 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(245),
+ /* 1755 S> */ B(LdaSmi), U8(1),
+ /* 1762 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(247),
+ /* 1769 S> */ B(LdaSmi), U8(1),
+ /* 1776 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(249),
+ /* 1783 S> */ B(LdaSmi), U8(1),
+ /* 1790 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(251),
+ /* 1797 S> */ B(LdaSmi), U8(1),
+ /* 1804 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(253),
+ /* 1811 S> */ B(LdaSmi), U8(1),
+ /* 1818 E> */ B(StaNamedPropertyStrict), R(arg0), U8(0), U8(255),
+ /* 1825 S> */ B(LdaSmi), U8(2),
+ /* 1832 E> */ B(Wide), B(StaNamedPropertyStrict), R16(arg0), U16(0), U16(257),
B(LdaUndefined),
/* 1837 S> */ B(Return),
]
@@ -1647,785 +1111,269 @@
}
f({name : \"test\"})
"
-frame size: 2
+frame size: 0
parameter count: 3
-bytecode array length: 1813
+bytecode array length: 781
bytecodes: [
/* 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),
+ /* 21 S> */ B(LdaSmi), U8(1),
+ /* 26 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(1),
+ /* 33 S> */ B(LdaSmi), U8(1),
+ /* 38 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(3),
+ /* 45 S> */ B(LdaSmi), U8(1),
+ /* 50 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(5),
+ /* 57 S> */ B(LdaSmi), U8(1),
+ /* 62 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(7),
+ /* 69 S> */ B(LdaSmi), U8(1),
+ /* 74 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(9),
+ /* 81 S> */ B(LdaSmi), U8(1),
+ /* 86 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(11),
+ /* 93 S> */ B(LdaSmi), U8(1),
+ /* 98 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(13),
+ /* 105 S> */ B(LdaSmi), U8(1),
+ /* 110 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(15),
+ /* 117 S> */ B(LdaSmi), U8(1),
+ /* 122 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(17),
+ /* 129 S> */ B(LdaSmi), U8(1),
+ /* 134 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(19),
+ /* 141 S> */ B(LdaSmi), U8(1),
+ /* 146 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(21),
+ /* 153 S> */ B(LdaSmi), U8(1),
+ /* 158 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(23),
+ /* 165 S> */ B(LdaSmi), U8(1),
+ /* 170 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(25),
+ /* 177 S> */ B(LdaSmi), U8(1),
+ /* 182 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(27),
+ /* 189 S> */ B(LdaSmi), U8(1),
+ /* 194 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(29),
+ /* 201 S> */ B(LdaSmi), U8(1),
+ /* 206 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(31),
+ /* 213 S> */ B(LdaSmi), U8(1),
+ /* 218 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(33),
+ /* 225 S> */ B(LdaSmi), U8(1),
+ /* 230 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(35),
+ /* 237 S> */ B(LdaSmi), U8(1),
+ /* 242 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(37),
+ /* 249 S> */ B(LdaSmi), U8(1),
+ /* 254 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(39),
+ /* 261 S> */ B(LdaSmi), U8(1),
+ /* 266 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(41),
+ /* 273 S> */ B(LdaSmi), U8(1),
+ /* 278 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(43),
+ /* 285 S> */ B(LdaSmi), U8(1),
+ /* 290 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(45),
+ /* 297 S> */ B(LdaSmi), U8(1),
+ /* 302 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(47),
+ /* 309 S> */ B(LdaSmi), U8(1),
+ /* 314 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(49),
+ /* 321 S> */ B(LdaSmi), U8(1),
+ /* 326 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(51),
+ /* 333 S> */ B(LdaSmi), U8(1),
+ /* 338 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(53),
+ /* 345 S> */ B(LdaSmi), U8(1),
+ /* 350 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(55),
+ /* 357 S> */ B(LdaSmi), U8(1),
+ /* 362 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(57),
+ /* 369 S> */ B(LdaSmi), U8(1),
+ /* 374 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(59),
+ /* 381 S> */ B(LdaSmi), U8(1),
+ /* 386 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(61),
+ /* 393 S> */ B(LdaSmi), U8(1),
+ /* 398 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(63),
+ /* 405 S> */ B(LdaSmi), U8(1),
+ /* 410 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(65),
+ /* 417 S> */ B(LdaSmi), U8(1),
+ /* 422 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(67),
+ /* 429 S> */ B(LdaSmi), U8(1),
+ /* 434 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(69),
+ /* 441 S> */ B(LdaSmi), U8(1),
+ /* 446 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(71),
+ /* 453 S> */ B(LdaSmi), U8(1),
+ /* 458 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(73),
+ /* 465 S> */ B(LdaSmi), U8(1),
+ /* 470 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(75),
+ /* 477 S> */ B(LdaSmi), U8(1),
+ /* 482 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(77),
+ /* 489 S> */ B(LdaSmi), U8(1),
+ /* 494 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(79),
+ /* 501 S> */ B(LdaSmi), U8(1),
+ /* 506 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(81),
+ /* 513 S> */ B(LdaSmi), U8(1),
+ /* 518 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(83),
+ /* 525 S> */ B(LdaSmi), U8(1),
+ /* 530 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(85),
+ /* 537 S> */ B(LdaSmi), U8(1),
+ /* 542 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(87),
+ /* 549 S> */ B(LdaSmi), U8(1),
+ /* 554 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(89),
+ /* 561 S> */ B(LdaSmi), U8(1),
+ /* 566 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(91),
+ /* 573 S> */ B(LdaSmi), U8(1),
+ /* 578 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(93),
+ /* 585 S> */ B(LdaSmi), U8(1),
+ /* 590 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(95),
+ /* 597 S> */ B(LdaSmi), U8(1),
+ /* 602 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(97),
+ /* 609 S> */ B(LdaSmi), U8(1),
+ /* 614 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(99),
+ /* 621 S> */ B(LdaSmi), U8(1),
+ /* 626 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(101),
+ /* 633 S> */ B(LdaSmi), U8(1),
+ /* 638 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(103),
+ /* 645 S> */ B(LdaSmi), U8(1),
+ /* 650 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(105),
+ /* 657 S> */ B(LdaSmi), U8(1),
+ /* 662 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(107),
+ /* 669 S> */ B(LdaSmi), U8(1),
+ /* 674 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(109),
+ /* 681 S> */ B(LdaSmi), U8(1),
+ /* 686 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(111),
+ /* 693 S> */ B(LdaSmi), U8(1),
+ /* 698 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(113),
+ /* 705 S> */ B(LdaSmi), U8(1),
+ /* 710 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(115),
+ /* 717 S> */ B(LdaSmi), U8(1),
+ /* 722 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(117),
+ /* 729 S> */ B(LdaSmi), U8(1),
+ /* 734 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(119),
+ /* 741 S> */ B(LdaSmi), U8(1),
+ /* 746 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(121),
+ /* 753 S> */ B(LdaSmi), U8(1),
+ /* 758 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(123),
+ /* 765 S> */ B(LdaSmi), U8(1),
+ /* 770 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(125),
+ /* 777 S> */ B(LdaSmi), U8(1),
+ /* 782 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(127),
+ /* 789 S> */ B(LdaSmi), U8(1),
+ /* 794 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(129),
+ /* 801 S> */ B(LdaSmi), U8(1),
+ /* 806 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(131),
+ /* 813 S> */ B(LdaSmi), U8(1),
+ /* 818 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(133),
+ /* 825 S> */ B(LdaSmi), U8(1),
+ /* 830 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(135),
+ /* 837 S> */ B(LdaSmi), U8(1),
+ /* 842 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(137),
+ /* 849 S> */ B(LdaSmi), U8(1),
+ /* 854 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(139),
+ /* 861 S> */ B(LdaSmi), U8(1),
+ /* 866 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(141),
+ /* 873 S> */ B(LdaSmi), U8(1),
+ /* 878 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(143),
+ /* 885 S> */ B(LdaSmi), U8(1),
+ /* 890 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(145),
+ /* 897 S> */ B(LdaSmi), U8(1),
+ /* 902 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(147),
+ /* 909 S> */ B(LdaSmi), U8(1),
+ /* 914 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(149),
+ /* 921 S> */ B(LdaSmi), U8(1),
+ /* 926 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(151),
+ /* 933 S> */ B(LdaSmi), U8(1),
+ /* 938 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(153),
+ /* 945 S> */ B(LdaSmi), U8(1),
+ /* 950 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(155),
+ /* 957 S> */ B(LdaSmi), U8(1),
+ /* 962 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(157),
+ /* 969 S> */ B(LdaSmi), U8(1),
+ /* 974 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(159),
+ /* 981 S> */ B(LdaSmi), U8(1),
+ /* 986 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(161),
+ /* 993 S> */ B(LdaSmi), U8(1),
+ /* 998 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(163),
+ /* 1005 S> */ B(LdaSmi), U8(1),
+ /* 1010 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(165),
+ /* 1017 S> */ B(LdaSmi), U8(1),
+ /* 1022 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(167),
+ /* 1029 S> */ B(LdaSmi), U8(1),
+ /* 1034 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(169),
+ /* 1041 S> */ B(LdaSmi), U8(1),
+ /* 1046 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(171),
+ /* 1053 S> */ B(LdaSmi), U8(1),
+ /* 1058 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(173),
+ /* 1065 S> */ B(LdaSmi), U8(1),
+ /* 1070 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(175),
+ /* 1077 S> */ B(LdaSmi), U8(1),
+ /* 1082 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(177),
+ /* 1089 S> */ B(LdaSmi), U8(1),
+ /* 1094 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(179),
+ /* 1101 S> */ B(LdaSmi), U8(1),
+ /* 1106 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(181),
+ /* 1113 S> */ B(LdaSmi), U8(1),
+ /* 1118 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(183),
+ /* 1125 S> */ B(LdaSmi), U8(1),
+ /* 1130 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(185),
+ /* 1137 S> */ B(LdaSmi), U8(1),
+ /* 1142 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(187),
+ /* 1149 S> */ B(LdaSmi), U8(1),
+ /* 1154 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(189),
+ /* 1161 S> */ B(LdaSmi), U8(1),
+ /* 1166 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(191),
+ /* 1173 S> */ B(LdaSmi), U8(1),
+ /* 1178 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(193),
+ /* 1185 S> */ B(LdaSmi), U8(1),
+ /* 1190 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(195),
+ /* 1197 S> */ B(LdaSmi), U8(1),
+ /* 1202 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(197),
+ /* 1209 S> */ B(LdaSmi), U8(1),
+ /* 1214 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(199),
+ /* 1221 S> */ B(LdaSmi), U8(1),
+ /* 1226 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(201),
+ /* 1233 S> */ B(LdaSmi), U8(1),
+ /* 1238 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(203),
+ /* 1245 S> */ B(LdaSmi), U8(1),
+ /* 1250 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(205),
+ /* 1257 S> */ B(LdaSmi), U8(1),
+ /* 1262 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(207),
+ /* 1269 S> */ B(LdaSmi), U8(1),
+ /* 1274 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(209),
+ /* 1281 S> */ B(LdaSmi), U8(1),
+ /* 1286 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(211),
+ /* 1293 S> */ B(LdaSmi), U8(1),
+ /* 1298 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(213),
+ /* 1305 S> */ B(LdaSmi), U8(1),
+ /* 1310 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(215),
+ /* 1317 S> */ B(LdaSmi), U8(1),
+ /* 1322 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(217),
+ /* 1329 S> */ B(LdaSmi), U8(1),
+ /* 1334 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(219),
+ /* 1341 S> */ B(LdaSmi), U8(1),
+ /* 1346 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(221),
+ /* 1353 S> */ B(LdaSmi), U8(1),
+ /* 1358 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(223),
+ /* 1365 S> */ B(LdaSmi), U8(1),
+ /* 1370 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(225),
+ /* 1377 S> */ B(LdaSmi), U8(1),
+ /* 1382 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(227),
+ /* 1389 S> */ B(LdaSmi), U8(1),
+ /* 1394 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(229),
+ /* 1401 S> */ B(LdaSmi), U8(1),
+ /* 1406 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(231),
+ /* 1413 S> */ B(LdaSmi), U8(1),
+ /* 1418 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(233),
+ /* 1425 S> */ B(LdaSmi), U8(1),
+ /* 1430 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(235),
+ /* 1437 S> */ B(LdaSmi), U8(1),
+ /* 1442 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(237),
+ /* 1449 S> */ B(LdaSmi), U8(1),
+ /* 1454 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(239),
+ /* 1461 S> */ B(LdaSmi), U8(1),
+ /* 1466 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(241),
+ /* 1473 S> */ B(LdaSmi), U8(1),
+ /* 1478 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(243),
+ /* 1485 S> */ B(LdaSmi), U8(1),
+ /* 1490 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(245),
+ /* 1497 S> */ B(LdaSmi), U8(1),
+ /* 1502 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(247),
+ /* 1509 S> */ B(LdaSmi), U8(1),
+ /* 1514 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(249),
+ /* 1521 S> */ B(LdaSmi), U8(1),
+ /* 1526 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(251),
+ /* 1533 S> */ B(LdaSmi), U8(1),
+ /* 1538 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(253),
+ /* 1545 S> */ B(LdaSmi), U8(1),
+ /* 1550 E> */ B(StaKeyedPropertySloppy), R(arg0), R(arg1), U8(255),
+ /* 1557 S> */ B(LdaSmi), U8(2),
+ /* 1562 E> */ B(Wide), B(StaKeyedPropertySloppy), R16(arg0), R16(arg1), U16(257),
B(LdaUndefined),
/* 1567 S> */ B(Return),
]
@@ -2570,785 +1518,269 @@
}
f({name : \"test\"})
"
-frame size: 2
+frame size: 0
parameter count: 3
-bytecode array length: 1813
+bytecode array length: 781
bytecodes: [
/* 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),
+ /* 37 S> */ B(LdaSmi), U8(1),
+ /* 42 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(1),
+ /* 49 S> */ B(LdaSmi), U8(1),
+ /* 54 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(3),
+ /* 61 S> */ B(LdaSmi), U8(1),
+ /* 66 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(5),
+ /* 73 S> */ B(LdaSmi), U8(1),
+ /* 78 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(7),
+ /* 85 S> */ B(LdaSmi), U8(1),
+ /* 90 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(9),
+ /* 97 S> */ B(LdaSmi), U8(1),
+ /* 102 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(11),
+ /* 109 S> */ B(LdaSmi), U8(1),
+ /* 114 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(13),
+ /* 121 S> */ B(LdaSmi), U8(1),
+ /* 126 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(15),
+ /* 133 S> */ B(LdaSmi), U8(1),
+ /* 138 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(17),
+ /* 145 S> */ B(LdaSmi), U8(1),
+ /* 150 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(19),
+ /* 157 S> */ B(LdaSmi), U8(1),
+ /* 162 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(21),
+ /* 169 S> */ B(LdaSmi), U8(1),
+ /* 174 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(23),
+ /* 181 S> */ B(LdaSmi), U8(1),
+ /* 186 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(25),
+ /* 193 S> */ B(LdaSmi), U8(1),
+ /* 198 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(27),
+ /* 205 S> */ B(LdaSmi), U8(1),
+ /* 210 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(29),
+ /* 217 S> */ B(LdaSmi), U8(1),
+ /* 222 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(31),
+ /* 229 S> */ B(LdaSmi), U8(1),
+ /* 234 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(33),
+ /* 241 S> */ B(LdaSmi), U8(1),
+ /* 246 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(35),
+ /* 253 S> */ B(LdaSmi), U8(1),
+ /* 258 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(37),
+ /* 265 S> */ B(LdaSmi), U8(1),
+ /* 270 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(39),
+ /* 277 S> */ B(LdaSmi), U8(1),
+ /* 282 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(41),
+ /* 289 S> */ B(LdaSmi), U8(1),
+ /* 294 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(43),
+ /* 301 S> */ B(LdaSmi), U8(1),
+ /* 306 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(45),
+ /* 313 S> */ B(LdaSmi), U8(1),
+ /* 318 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(47),
+ /* 325 S> */ B(LdaSmi), U8(1),
+ /* 330 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(49),
+ /* 337 S> */ B(LdaSmi), U8(1),
+ /* 342 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(51),
+ /* 349 S> */ B(LdaSmi), U8(1),
+ /* 354 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(53),
+ /* 361 S> */ B(LdaSmi), U8(1),
+ /* 366 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(55),
+ /* 373 S> */ B(LdaSmi), U8(1),
+ /* 378 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(57),
+ /* 385 S> */ B(LdaSmi), U8(1),
+ /* 390 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(59),
+ /* 397 S> */ B(LdaSmi), U8(1),
+ /* 402 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(61),
+ /* 409 S> */ B(LdaSmi), U8(1),
+ /* 414 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(63),
+ /* 421 S> */ B(LdaSmi), U8(1),
+ /* 426 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(65),
+ /* 433 S> */ B(LdaSmi), U8(1),
+ /* 438 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(67),
+ /* 445 S> */ B(LdaSmi), U8(1),
+ /* 450 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(69),
+ /* 457 S> */ B(LdaSmi), U8(1),
+ /* 462 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(71),
+ /* 469 S> */ B(LdaSmi), U8(1),
+ /* 474 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(73),
+ /* 481 S> */ B(LdaSmi), U8(1),
+ /* 486 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(75),
+ /* 493 S> */ B(LdaSmi), U8(1),
+ /* 498 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(77),
+ /* 505 S> */ B(LdaSmi), U8(1),
+ /* 510 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(79),
+ /* 517 S> */ B(LdaSmi), U8(1),
+ /* 522 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(81),
+ /* 529 S> */ B(LdaSmi), U8(1),
+ /* 534 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(83),
+ /* 541 S> */ B(LdaSmi), U8(1),
+ /* 546 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(85),
+ /* 553 S> */ B(LdaSmi), U8(1),
+ /* 558 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(87),
+ /* 565 S> */ B(LdaSmi), U8(1),
+ /* 570 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(89),
+ /* 577 S> */ B(LdaSmi), U8(1),
+ /* 582 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(91),
+ /* 589 S> */ B(LdaSmi), U8(1),
+ /* 594 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(93),
+ /* 601 S> */ B(LdaSmi), U8(1),
+ /* 606 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(95),
+ /* 613 S> */ B(LdaSmi), U8(1),
+ /* 618 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(97),
+ /* 625 S> */ B(LdaSmi), U8(1),
+ /* 630 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(99),
+ /* 637 S> */ B(LdaSmi), U8(1),
+ /* 642 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(101),
+ /* 649 S> */ B(LdaSmi), U8(1),
+ /* 654 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(103),
+ /* 661 S> */ B(LdaSmi), U8(1),
+ /* 666 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(105),
+ /* 673 S> */ B(LdaSmi), U8(1),
+ /* 678 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(107),
+ /* 685 S> */ B(LdaSmi), U8(1),
+ /* 690 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(109),
+ /* 697 S> */ B(LdaSmi), U8(1),
+ /* 702 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(111),
+ /* 709 S> */ B(LdaSmi), U8(1),
+ /* 714 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(113),
+ /* 721 S> */ B(LdaSmi), U8(1),
+ /* 726 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(115),
+ /* 733 S> */ B(LdaSmi), U8(1),
+ /* 738 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(117),
+ /* 745 S> */ B(LdaSmi), U8(1),
+ /* 750 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(119),
+ /* 757 S> */ B(LdaSmi), U8(1),
+ /* 762 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(121),
+ /* 769 S> */ B(LdaSmi), U8(1),
+ /* 774 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(123),
+ /* 781 S> */ B(LdaSmi), U8(1),
+ /* 786 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(125),
+ /* 793 S> */ B(LdaSmi), U8(1),
+ /* 798 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(127),
+ /* 805 S> */ B(LdaSmi), U8(1),
+ /* 810 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(129),
+ /* 817 S> */ B(LdaSmi), U8(1),
+ /* 822 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(131),
+ /* 829 S> */ B(LdaSmi), U8(1),
+ /* 834 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(133),
+ /* 841 S> */ B(LdaSmi), U8(1),
+ /* 846 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(135),
+ /* 853 S> */ B(LdaSmi), U8(1),
+ /* 858 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(137),
+ /* 865 S> */ B(LdaSmi), U8(1),
+ /* 870 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(139),
+ /* 877 S> */ B(LdaSmi), U8(1),
+ /* 882 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(141),
+ /* 889 S> */ B(LdaSmi), U8(1),
+ /* 894 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(143),
+ /* 901 S> */ B(LdaSmi), U8(1),
+ /* 906 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(145),
+ /* 913 S> */ B(LdaSmi), U8(1),
+ /* 918 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(147),
+ /* 925 S> */ B(LdaSmi), U8(1),
+ /* 930 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(149),
+ /* 937 S> */ B(LdaSmi), U8(1),
+ /* 942 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(151),
+ /* 949 S> */ B(LdaSmi), U8(1),
+ /* 954 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(153),
+ /* 961 S> */ B(LdaSmi), U8(1),
+ /* 966 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(155),
+ /* 973 S> */ B(LdaSmi), U8(1),
+ /* 978 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(157),
+ /* 985 S> */ B(LdaSmi), U8(1),
+ /* 990 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(159),
+ /* 997 S> */ B(LdaSmi), U8(1),
+ /* 1002 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(161),
+ /* 1009 S> */ B(LdaSmi), U8(1),
+ /* 1014 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(163),
+ /* 1021 S> */ B(LdaSmi), U8(1),
+ /* 1026 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(165),
+ /* 1033 S> */ B(LdaSmi), U8(1),
+ /* 1038 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(167),
+ /* 1045 S> */ B(LdaSmi), U8(1),
+ /* 1050 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(169),
+ /* 1057 S> */ B(LdaSmi), U8(1),
+ /* 1062 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(171),
+ /* 1069 S> */ B(LdaSmi), U8(1),
+ /* 1074 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(173),
+ /* 1081 S> */ B(LdaSmi), U8(1),
+ /* 1086 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(175),
+ /* 1093 S> */ B(LdaSmi), U8(1),
+ /* 1098 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(177),
+ /* 1105 S> */ B(LdaSmi), U8(1),
+ /* 1110 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(179),
+ /* 1117 S> */ B(LdaSmi), U8(1),
+ /* 1122 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(181),
+ /* 1129 S> */ B(LdaSmi), U8(1),
+ /* 1134 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(183),
+ /* 1141 S> */ B(LdaSmi), U8(1),
+ /* 1146 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(185),
+ /* 1153 S> */ B(LdaSmi), U8(1),
+ /* 1158 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(187),
+ /* 1165 S> */ B(LdaSmi), U8(1),
+ /* 1170 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(189),
+ /* 1177 S> */ B(LdaSmi), U8(1),
+ /* 1182 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(191),
+ /* 1189 S> */ B(LdaSmi), U8(1),
+ /* 1194 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(193),
+ /* 1201 S> */ B(LdaSmi), U8(1),
+ /* 1206 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(195),
+ /* 1213 S> */ B(LdaSmi), U8(1),
+ /* 1218 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(197),
+ /* 1225 S> */ B(LdaSmi), U8(1),
+ /* 1230 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(199),
+ /* 1237 S> */ B(LdaSmi), U8(1),
+ /* 1242 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(201),
+ /* 1249 S> */ B(LdaSmi), U8(1),
+ /* 1254 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(203),
+ /* 1261 S> */ B(LdaSmi), U8(1),
+ /* 1266 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(205),
+ /* 1273 S> */ B(LdaSmi), U8(1),
+ /* 1278 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(207),
+ /* 1285 S> */ B(LdaSmi), U8(1),
+ /* 1290 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(209),
+ /* 1297 S> */ B(LdaSmi), U8(1),
+ /* 1302 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(211),
+ /* 1309 S> */ B(LdaSmi), U8(1),
+ /* 1314 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(213),
+ /* 1321 S> */ B(LdaSmi), U8(1),
+ /* 1326 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(215),
+ /* 1333 S> */ B(LdaSmi), U8(1),
+ /* 1338 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(217),
+ /* 1345 S> */ B(LdaSmi), U8(1),
+ /* 1350 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(219),
+ /* 1357 S> */ B(LdaSmi), U8(1),
+ /* 1362 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(221),
+ /* 1369 S> */ B(LdaSmi), U8(1),
+ /* 1374 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(223),
+ /* 1381 S> */ B(LdaSmi), U8(1),
+ /* 1386 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(225),
+ /* 1393 S> */ B(LdaSmi), U8(1),
+ /* 1398 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(227),
+ /* 1405 S> */ B(LdaSmi), U8(1),
+ /* 1410 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(229),
+ /* 1417 S> */ B(LdaSmi), U8(1),
+ /* 1422 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(231),
+ /* 1429 S> */ B(LdaSmi), U8(1),
+ /* 1434 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(233),
+ /* 1441 S> */ B(LdaSmi), U8(1),
+ /* 1446 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(235),
+ /* 1453 S> */ B(LdaSmi), U8(1),
+ /* 1458 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(237),
+ /* 1465 S> */ B(LdaSmi), U8(1),
+ /* 1470 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(239),
+ /* 1477 S> */ B(LdaSmi), U8(1),
+ /* 1482 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(241),
+ /* 1489 S> */ B(LdaSmi), U8(1),
+ /* 1494 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(243),
+ /* 1501 S> */ B(LdaSmi), U8(1),
+ /* 1506 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(245),
+ /* 1513 S> */ B(LdaSmi), U8(1),
+ /* 1518 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(247),
+ /* 1525 S> */ B(LdaSmi), U8(1),
+ /* 1530 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(249),
+ /* 1537 S> */ B(LdaSmi), U8(1),
+ /* 1542 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(251),
+ /* 1549 S> */ B(LdaSmi), U8(1),
+ /* 1554 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(253),
+ /* 1561 S> */ B(LdaSmi), U8(1),
+ /* 1566 E> */ B(StaKeyedPropertyStrict), R(arg0), R(arg1), U8(255),
+ /* 1573 S> */ B(LdaSmi), U8(2),
+ /* 1578 E> */ B(Wide), B(StaKeyedPropertyStrict), R16(arg0), R16(arg1), U16(257),
B(LdaUndefined),
/* 1583 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/RegExpLiterals.golden b/test/cctest/interpreter/bytecode_expectations/RegExpLiterals.golden
index 01ae49c..210a350 100644
--- a/test/cctest/interpreter/bytecode_expectations/RegExpLiterals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/RegExpLiterals.golden
@@ -49,13 +49,12 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 23
+bytecode array length: 22
bytecodes: [
/* 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),
+ /* 47 E> */ B(LdrNamedProperty), R(1), U8(1), U8(3), R(0),
B(LdaConstant), U8(2),
B(Star), R(2),
/* 48 E> */ B(Call), R(0), R(1), U8(2), U8(1),
diff --git a/test/cctest/interpreter/bytecode_expectations/RegExpLiteralsWide.golden b/test/cctest/interpreter/bytecode_expectations/RegExpLiteralsWide.golden
index a8345a6..3c5499b 100644
--- a/test/cctest/interpreter/bytecode_expectations/RegExpLiteralsWide.golden
+++ b/test/cctest/interpreter/bytecode_expectations/RegExpLiteralsWide.golden
@@ -274,517 +274,517 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 41 S> */ B(LdaConstant), U8(0),
- /* 43 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 51 S> */ B(LdaConstant), U8(1),
- /* 53 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 61 S> */ B(LdaConstant), U8(2),
- /* 63 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 71 S> */ B(LdaConstant), U8(3),
- /* 73 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 81 S> */ B(LdaConstant), U8(4),
- /* 83 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 91 S> */ B(LdaConstant), U8(5),
- /* 93 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 101 S> */ B(LdaConstant), U8(6),
- /* 103 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 111 S> */ B(LdaConstant), U8(7),
- /* 113 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 121 S> */ B(LdaConstant), U8(8),
- /* 123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 131 S> */ B(LdaConstant), U8(9),
- /* 133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 141 S> */ B(LdaConstant), U8(10),
- /* 143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 151 S> */ B(LdaConstant), U8(11),
- /* 153 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 161 S> */ B(LdaConstant), U8(12),
- /* 163 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 171 S> */ B(LdaConstant), U8(13),
- /* 173 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 181 S> */ B(LdaConstant), U8(14),
- /* 183 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 191 S> */ B(LdaConstant), U8(15),
- /* 193 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 201 S> */ B(LdaConstant), U8(16),
- /* 203 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 211 S> */ B(LdaConstant), U8(17),
- /* 213 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 221 S> */ B(LdaConstant), U8(18),
- /* 223 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 231 S> */ B(LdaConstant), U8(19),
- /* 233 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 241 S> */ B(LdaConstant), U8(20),
- /* 243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 251 S> */ B(LdaConstant), U8(21),
- /* 253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 261 S> */ B(LdaConstant), U8(22),
- /* 263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 271 S> */ B(LdaConstant), U8(23),
- /* 273 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 281 S> */ B(LdaConstant), U8(24),
- /* 283 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 291 S> */ B(LdaConstant), U8(25),
- /* 293 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 301 S> */ B(LdaConstant), U8(26),
- /* 303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 311 S> */ B(LdaConstant), U8(27),
- /* 313 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 321 S> */ B(LdaConstant), U8(28),
- /* 323 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 331 S> */ B(LdaConstant), U8(29),
- /* 333 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 341 S> */ B(LdaConstant), U8(30),
- /* 343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 351 S> */ B(LdaConstant), U8(31),
- /* 353 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 361 S> */ B(LdaConstant), U8(32),
- /* 363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 371 S> */ B(LdaConstant), U8(33),
- /* 373 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 381 S> */ B(LdaConstant), U8(34),
- /* 383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 391 S> */ B(LdaConstant), U8(35),
- /* 393 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 401 S> */ B(LdaConstant), U8(36),
- /* 403 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 411 S> */ B(LdaConstant), U8(37),
- /* 413 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 421 S> */ B(LdaConstant), U8(38),
- /* 423 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 431 S> */ B(LdaConstant), U8(39),
- /* 433 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 441 S> */ B(LdaConstant), U8(40),
- /* 443 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 451 S> */ B(LdaConstant), U8(41),
- /* 453 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 461 S> */ B(LdaConstant), U8(42),
- /* 463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 471 S> */ B(LdaConstant), U8(43),
- /* 473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 481 S> */ B(LdaConstant), U8(44),
- /* 483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 491 S> */ B(LdaConstant), U8(45),
- /* 493 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 501 S> */ B(LdaConstant), U8(46),
- /* 503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 511 S> */ B(LdaConstant), U8(47),
- /* 513 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 521 S> */ B(LdaConstant), U8(48),
- /* 523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 531 S> */ B(LdaConstant), U8(49),
- /* 533 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 541 S> */ B(LdaConstant), U8(50),
- /* 543 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 551 S> */ B(LdaConstant), U8(51),
- /* 553 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 561 S> */ B(LdaConstant), U8(52),
- /* 563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 571 S> */ B(LdaConstant), U8(53),
- /* 573 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 581 S> */ B(LdaConstant), U8(54),
- /* 583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 591 S> */ B(LdaConstant), U8(55),
- /* 593 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 601 S> */ B(LdaConstant), U8(56),
- /* 603 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 611 S> */ B(LdaConstant), U8(57),
- /* 613 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 621 S> */ B(LdaConstant), U8(58),
- /* 623 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 631 S> */ B(LdaConstant), U8(59),
- /* 633 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 641 S> */ B(LdaConstant), U8(60),
- /* 643 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 651 S> */ B(LdaConstant), U8(61),
- /* 653 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 661 S> */ B(LdaConstant), U8(62),
- /* 663 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 671 S> */ B(LdaConstant), U8(63),
- /* 673 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 681 S> */ B(LdaConstant), U8(64),
- /* 683 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 691 S> */ B(LdaConstant), U8(65),
- /* 693 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 701 S> */ B(LdaConstant), U8(66),
- /* 703 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 711 S> */ B(LdaConstant), U8(67),
- /* 713 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 721 S> */ B(LdaConstant), U8(68),
- /* 723 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 731 S> */ B(LdaConstant), U8(69),
- /* 733 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 741 S> */ B(LdaConstant), U8(70),
- /* 743 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 751 S> */ B(LdaConstant), U8(71),
- /* 753 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 761 S> */ B(LdaConstant), U8(72),
- /* 763 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 771 S> */ B(LdaConstant), U8(73),
- /* 773 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 781 S> */ B(LdaConstant), U8(74),
- /* 783 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 791 S> */ B(LdaConstant), U8(75),
- /* 793 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 801 S> */ B(LdaConstant), U8(76),
- /* 803 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 811 S> */ B(LdaConstant), U8(77),
- /* 813 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 821 S> */ B(LdaConstant), U8(78),
- /* 823 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 831 S> */ B(LdaConstant), U8(79),
- /* 833 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 841 S> */ B(LdaConstant), U8(80),
- /* 843 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 851 S> */ B(LdaConstant), U8(81),
- /* 853 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 861 S> */ B(LdaConstant), U8(82),
- /* 863 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 871 S> */ B(LdaConstant), U8(83),
- /* 873 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 881 S> */ B(LdaConstant), U8(84),
- /* 883 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 891 S> */ B(LdaConstant), U8(85),
- /* 893 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 901 S> */ B(LdaConstant), U8(86),
- /* 903 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 911 S> */ B(LdaConstant), U8(87),
- /* 913 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 921 S> */ B(LdaConstant), U8(88),
- /* 923 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 931 S> */ B(LdaConstant), U8(89),
- /* 933 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 941 S> */ B(LdaConstant), U8(90),
- /* 943 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 951 S> */ B(LdaConstant), U8(91),
- /* 953 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 961 S> */ B(LdaConstant), U8(92),
- /* 963 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 971 S> */ B(LdaConstant), U8(93),
- /* 973 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 981 S> */ B(LdaConstant), U8(94),
- /* 983 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 991 S> */ B(LdaConstant), U8(95),
- /* 993 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1001 S> */ B(LdaConstant), U8(96),
- /* 1003 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1011 S> */ B(LdaConstant), U8(97),
- /* 1013 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1021 S> */ B(LdaConstant), U8(98),
- /* 1023 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1031 S> */ B(LdaConstant), U8(99),
- /* 1033 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1041 S> */ B(LdaConstant), U8(100),
- /* 1043 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1051 S> */ B(LdaConstant), U8(101),
- /* 1053 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1061 S> */ B(LdaConstant), U8(102),
- /* 1063 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1071 S> */ B(LdaConstant), U8(103),
- /* 1073 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1081 S> */ B(LdaConstant), U8(104),
- /* 1083 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1091 S> */ B(LdaConstant), U8(105),
- /* 1093 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1101 S> */ B(LdaConstant), U8(106),
- /* 1103 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1111 S> */ B(LdaConstant), U8(107),
- /* 1113 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1121 S> */ B(LdaConstant), U8(108),
- /* 1123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1131 S> */ B(LdaConstant), U8(109),
- /* 1133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1141 S> */ B(LdaConstant), U8(110),
- /* 1143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1151 S> */ B(LdaConstant), U8(111),
- /* 1153 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1161 S> */ B(LdaConstant), U8(112),
- /* 1163 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1171 S> */ B(LdaConstant), U8(113),
- /* 1173 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1181 S> */ B(LdaConstant), U8(114),
- /* 1183 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1191 S> */ B(LdaConstant), U8(115),
- /* 1193 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1201 S> */ B(LdaConstant), U8(116),
- /* 1203 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1211 S> */ B(LdaConstant), U8(117),
- /* 1213 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1221 S> */ B(LdaConstant), U8(118),
- /* 1223 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1231 S> */ B(LdaConstant), U8(119),
- /* 1233 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1241 S> */ B(LdaConstant), U8(120),
- /* 1243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1251 S> */ B(LdaConstant), U8(121),
- /* 1253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1261 S> */ B(LdaConstant), U8(122),
- /* 1263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1271 S> */ B(LdaConstant), U8(123),
- /* 1273 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1281 S> */ B(LdaConstant), U8(124),
- /* 1283 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1291 S> */ B(LdaConstant), U8(125),
- /* 1293 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1301 S> */ B(LdaConstant), U8(126),
- /* 1303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1311 S> */ B(LdaConstant), U8(127),
- /* 1313 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1321 S> */ B(LdaConstant), U8(128),
- /* 1323 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1331 S> */ B(LdaConstant), U8(129),
- /* 1333 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1341 S> */ B(LdaConstant), U8(130),
- /* 1343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1351 S> */ B(LdaConstant), U8(131),
- /* 1353 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1361 S> */ B(LdaConstant), U8(132),
- /* 1363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1371 S> */ B(LdaConstant), U8(133),
- /* 1373 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1381 S> */ B(LdaConstant), U8(134),
- /* 1383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1391 S> */ B(LdaConstant), U8(135),
- /* 1393 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1401 S> */ B(LdaConstant), U8(136),
- /* 1403 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1411 S> */ B(LdaConstant), U8(137),
- /* 1413 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1421 S> */ B(LdaConstant), U8(138),
- /* 1423 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1431 S> */ B(LdaConstant), U8(139),
- /* 1433 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1441 S> */ B(LdaConstant), U8(140),
- /* 1443 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1451 S> */ B(LdaConstant), U8(141),
- /* 1453 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1461 S> */ B(LdaConstant), U8(142),
- /* 1463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1471 S> */ B(LdaConstant), U8(143),
- /* 1473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1481 S> */ B(LdaConstant), U8(144),
- /* 1483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1491 S> */ B(LdaConstant), U8(145),
- /* 1493 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1501 S> */ B(LdaConstant), U8(146),
- /* 1503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1511 S> */ B(LdaConstant), U8(147),
- /* 1513 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1521 S> */ B(LdaConstant), U8(148),
- /* 1523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1531 S> */ B(LdaConstant), U8(149),
- /* 1533 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1541 S> */ B(LdaConstant), U8(150),
- /* 1543 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1551 S> */ B(LdaConstant), U8(151),
- /* 1553 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1561 S> */ B(LdaConstant), U8(152),
- /* 1563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1571 S> */ B(LdaConstant), U8(153),
- /* 1573 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1581 S> */ B(LdaConstant), U8(154),
- /* 1583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1591 S> */ B(LdaConstant), U8(155),
- /* 1593 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1601 S> */ B(LdaConstant), U8(156),
- /* 1603 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1611 S> */ B(LdaConstant), U8(157),
- /* 1613 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1621 S> */ B(LdaConstant), U8(158),
- /* 1623 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1631 S> */ B(LdaConstant), U8(159),
- /* 1633 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1641 S> */ B(LdaConstant), U8(160),
- /* 1643 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1651 S> */ B(LdaConstant), U8(161),
- /* 1653 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1661 S> */ B(LdaConstant), U8(162),
- /* 1663 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1671 S> */ B(LdaConstant), U8(163),
- /* 1673 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1681 S> */ B(LdaConstant), U8(164),
- /* 1683 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1691 S> */ B(LdaConstant), U8(165),
- /* 1693 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1701 S> */ B(LdaConstant), U8(166),
- /* 1703 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1711 S> */ B(LdaConstant), U8(167),
- /* 1713 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1721 S> */ B(LdaConstant), U8(168),
- /* 1723 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1731 S> */ B(LdaConstant), U8(169),
- /* 1733 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1741 S> */ B(LdaConstant), U8(170),
- /* 1743 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1751 S> */ B(LdaConstant), U8(171),
- /* 1753 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1761 S> */ B(LdaConstant), U8(172),
- /* 1763 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1771 S> */ B(LdaConstant), U8(173),
- /* 1773 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1781 S> */ B(LdaConstant), U8(174),
- /* 1783 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1791 S> */ B(LdaConstant), U8(175),
- /* 1793 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1801 S> */ B(LdaConstant), U8(176),
- /* 1803 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1811 S> */ B(LdaConstant), U8(177),
- /* 1813 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1821 S> */ B(LdaConstant), U8(178),
- /* 1823 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1831 S> */ B(LdaConstant), U8(179),
- /* 1833 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1841 S> */ B(LdaConstant), U8(180),
- /* 1843 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1851 S> */ B(LdaConstant), U8(181),
- /* 1853 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1861 S> */ B(LdaConstant), U8(182),
- /* 1863 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1871 S> */ B(LdaConstant), U8(183),
- /* 1873 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1881 S> */ B(LdaConstant), U8(184),
- /* 1883 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1891 S> */ B(LdaConstant), U8(185),
- /* 1893 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1901 S> */ B(LdaConstant), U8(186),
- /* 1903 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1911 S> */ B(LdaConstant), U8(187),
- /* 1913 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1921 S> */ B(LdaConstant), U8(188),
- /* 1923 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1931 S> */ B(LdaConstant), U8(189),
- /* 1933 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1941 S> */ B(LdaConstant), U8(190),
- /* 1943 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1951 S> */ B(LdaConstant), U8(191),
- /* 1953 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1961 S> */ B(LdaConstant), U8(192),
- /* 1963 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1971 S> */ B(LdaConstant), U8(193),
- /* 1973 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1981 S> */ B(LdaConstant), U8(194),
- /* 1983 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1991 S> */ B(LdaConstant), U8(195),
- /* 1993 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2001 S> */ B(LdaConstant), U8(196),
- /* 2003 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2011 S> */ B(LdaConstant), U8(197),
- /* 2013 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2021 S> */ B(LdaConstant), U8(198),
- /* 2023 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2031 S> */ B(LdaConstant), U8(199),
- /* 2033 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2041 S> */ B(LdaConstant), U8(200),
- /* 2043 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2051 S> */ B(LdaConstant), U8(201),
- /* 2053 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2061 S> */ B(LdaConstant), U8(202),
- /* 2063 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2071 S> */ B(LdaConstant), U8(203),
- /* 2073 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2081 S> */ B(LdaConstant), U8(204),
- /* 2083 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2091 S> */ B(LdaConstant), U8(205),
- /* 2093 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2101 S> */ B(LdaConstant), U8(206),
- /* 2103 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2111 S> */ B(LdaConstant), U8(207),
- /* 2113 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2121 S> */ B(LdaConstant), U8(208),
- /* 2123 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2131 S> */ B(LdaConstant), U8(209),
- /* 2133 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2141 S> */ B(LdaConstant), U8(210),
- /* 2143 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2151 S> */ B(LdaConstant), U8(211),
- /* 2153 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2161 S> */ B(LdaConstant), U8(212),
- /* 2163 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2171 S> */ B(LdaConstant), U8(213),
- /* 2173 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2181 S> */ B(LdaConstant), U8(214),
- /* 2183 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2191 S> */ B(LdaConstant), U8(215),
- /* 2193 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2201 S> */ B(LdaConstant), U8(216),
- /* 2203 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2211 S> */ B(LdaConstant), U8(217),
- /* 2213 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2221 S> */ B(LdaConstant), U8(218),
- /* 2223 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2231 S> */ B(LdaConstant), U8(219),
- /* 2233 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2241 S> */ B(LdaConstant), U8(220),
- /* 2243 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2251 S> */ B(LdaConstant), U8(221),
- /* 2253 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2261 S> */ B(LdaConstant), U8(222),
- /* 2263 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2271 S> */ B(LdaConstant), U8(223),
- /* 2273 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2281 S> */ B(LdaConstant), U8(224),
- /* 2283 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2291 S> */ B(LdaConstant), U8(225),
- /* 2293 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2301 S> */ B(LdaConstant), U8(226),
- /* 2303 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2311 S> */ B(LdaConstant), U8(227),
- /* 2313 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2321 S> */ B(LdaConstant), U8(228),
- /* 2323 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2331 S> */ B(LdaConstant), U8(229),
- /* 2333 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2341 S> */ B(LdaConstant), U8(230),
- /* 2343 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2351 S> */ B(LdaConstant), U8(231),
- /* 2353 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2361 S> */ B(LdaConstant), U8(232),
- /* 2363 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2371 S> */ B(LdaConstant), U8(233),
- /* 2373 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2381 S> */ B(LdaConstant), U8(234),
- /* 2383 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2391 S> */ B(LdaConstant), U8(235),
- /* 2393 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2401 S> */ B(LdaConstant), U8(236),
- /* 2403 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2411 S> */ B(LdaConstant), U8(237),
- /* 2413 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2421 S> */ B(LdaConstant), U8(238),
- /* 2423 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2431 S> */ B(LdaConstant), U8(239),
- /* 2433 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2441 S> */ B(LdaConstant), U8(240),
- /* 2443 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2451 S> */ B(LdaConstant), U8(241),
- /* 2453 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2461 S> */ B(LdaConstant), U8(242),
- /* 2463 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2471 S> */ B(LdaConstant), U8(243),
- /* 2473 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2481 S> */ B(LdaConstant), U8(244),
- /* 2483 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2491 S> */ B(LdaConstant), U8(245),
- /* 2493 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2501 S> */ B(LdaConstant), U8(246),
- /* 2503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2511 S> */ B(LdaConstant), U8(247),
- /* 2513 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2521 S> */ B(LdaConstant), U8(248),
- /* 2523 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2531 S> */ B(LdaConstant), U8(249),
- /* 2533 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2541 S> */ B(LdaConstant), U8(250),
- /* 2543 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2551 S> */ B(LdaConstant), U8(251),
- /* 2553 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2561 S> */ B(LdaConstant), U8(252),
- /* 2563 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2571 S> */ B(LdaConstant), U8(253),
- /* 2573 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2581 S> */ B(LdaConstant), U8(254),
- /* 2583 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2591 S> */ B(LdaConstant), U8(255),
- /* 2593 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 2601 S> */ B(Wide), B(CreateRegExpLiteral), U16(256), U16(0), U8(0),
/* 2616 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/RemoveRedundantLdar.golden b/test/cctest/interpreter/bytecode_expectations/RemoveRedundantLdar.golden
index b5ebec1..d96a3bc 100644
--- a/test/cctest/interpreter/bytecode_expectations/RemoveRedundantLdar.golden
+++ b/test/cctest/interpreter/bytecode_expectations/RemoveRedundantLdar.golden
@@ -16,25 +16,22 @@
}
return ld_a;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 31
+bytecode array length: 25
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 45 S> */ B(LdaSmi), U8(1),
- /* 45 E> */ B(Star), R(0),
+ 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),
+ /* 78 E> */ B(Add), R(0),
+ B(Star), R(0),
+ /* 86 S> */ B(LdaSmi), U8(10),
+ /* 95 E> */ B(TestGreaterThan), R(0),
B(JumpIfFalse), U8(4),
/* 101 S> */ B(Jump), U8(4),
- B(Jump), U8(-21),
+ B(Jump), U8(-15),
/* 110 S> */ B(Ldar), R(0),
/* 123 S> */ B(Return),
]
@@ -52,22 +49,19 @@
} while(false);
return ld_a;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 29
+bytecode array length: 23
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 45 S> */ B(LdaSmi), U8(1),
- /* 45 E> */ B(Star), R(0),
+ 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),
+ /* 69 E> */ B(Add), R(0),
+ B(Star), R(0),
+ /* 77 S> */ B(LdaSmi), U8(10),
+ /* 86 E> */ B(TestGreaterThan), R(0),
B(JumpIfFalse), U8(4),
/* 92 S> */ B(Jump), U8(2),
/* 118 S> */ B(Ldar), R(0),
@@ -84,17 +78,17 @@
ld_a = ld_a + ld_a;
return ld_a;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 14
+bytecode array length: 12
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 50 S> */ B(Nop),
+ /* 64 E> */ B(Add), R(0),
+ B(Star), R(0),
+ /* 72 S> */ B(Nop),
/* 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 bddfe77..5cc49b2 100644
--- a/test/cctest/interpreter/bytecode_expectations/StoreGlobal.golden
+++ b/test/cctest/interpreter/bytecode_expectations/StoreGlobal.golden
@@ -231,395 +231,267 @@
}
f({name: 1});
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 1035
+bytecode array length: 651
bytecodes: [
/* 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),
+ /* 25 S> */ B(Nop),
+ /* 26 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(1),
+ /* 35 S> */ B(Nop),
+ /* 36 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(3),
+ /* 45 S> */ B(Nop),
+ /* 46 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(5),
+ /* 55 S> */ B(Nop),
+ /* 56 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(7),
+ /* 65 S> */ B(Nop),
+ /* 66 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(9),
+ /* 75 S> */ B(Nop),
+ /* 76 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(11),
+ /* 85 S> */ B(Nop),
+ /* 86 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(13),
+ /* 95 S> */ B(Nop),
+ /* 96 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(15),
+ /* 105 S> */ B(Nop),
+ /* 106 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(17),
+ /* 115 S> */ B(Nop),
+ /* 116 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(19),
+ /* 125 S> */ B(Nop),
+ /* 126 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(21),
+ /* 135 S> */ B(Nop),
+ /* 136 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(23),
+ /* 145 S> */ B(Nop),
+ /* 146 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(25),
+ /* 155 S> */ B(Nop),
+ /* 156 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(27),
+ /* 165 S> */ B(Nop),
+ /* 166 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(29),
+ /* 175 S> */ B(Nop),
+ /* 176 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(31),
+ /* 185 S> */ B(Nop),
+ /* 186 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(33),
+ /* 195 S> */ B(Nop),
+ /* 196 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(35),
+ /* 205 S> */ B(Nop),
+ /* 206 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(37),
+ /* 215 S> */ B(Nop),
+ /* 216 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(39),
+ /* 225 S> */ B(Nop),
+ /* 226 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(41),
+ /* 235 S> */ B(Nop),
+ /* 236 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(43),
+ /* 245 S> */ B(Nop),
+ /* 246 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(45),
+ /* 255 S> */ B(Nop),
+ /* 256 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(47),
+ /* 265 S> */ B(Nop),
+ /* 266 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(49),
+ /* 275 S> */ B(Nop),
+ /* 276 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(51),
+ /* 285 S> */ B(Nop),
+ /* 286 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(53),
+ /* 295 S> */ B(Nop),
+ /* 296 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(55),
+ /* 305 S> */ B(Nop),
+ /* 306 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(57),
+ /* 315 S> */ B(Nop),
+ /* 316 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(59),
+ /* 325 S> */ B(Nop),
+ /* 326 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(61),
+ /* 335 S> */ B(Nop),
+ /* 336 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(63),
+ /* 345 S> */ B(Nop),
+ /* 346 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(65),
+ /* 355 S> */ B(Nop),
+ /* 356 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(67),
+ /* 365 S> */ B(Nop),
+ /* 366 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(69),
+ /* 375 S> */ B(Nop),
+ /* 376 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(71),
+ /* 385 S> */ B(Nop),
+ /* 386 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(73),
+ /* 395 S> */ B(Nop),
+ /* 396 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(75),
+ /* 405 S> */ B(Nop),
+ /* 406 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(77),
+ /* 415 S> */ B(Nop),
+ /* 416 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(79),
+ /* 425 S> */ B(Nop),
+ /* 426 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(81),
+ /* 435 S> */ B(Nop),
+ /* 436 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(83),
+ /* 445 S> */ B(Nop),
+ /* 446 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(85),
+ /* 455 S> */ B(Nop),
+ /* 456 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(87),
+ /* 465 S> */ B(Nop),
+ /* 466 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(89),
+ /* 475 S> */ B(Nop),
+ /* 476 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(91),
+ /* 485 S> */ B(Nop),
+ /* 486 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(93),
+ /* 495 S> */ B(Nop),
+ /* 496 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(95),
+ /* 505 S> */ B(Nop),
+ /* 506 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(97),
+ /* 515 S> */ B(Nop),
+ /* 516 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(99),
+ /* 525 S> */ B(Nop),
+ /* 526 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(101),
+ /* 535 S> */ B(Nop),
+ /* 536 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(103),
+ /* 545 S> */ B(Nop),
+ /* 546 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(105),
+ /* 555 S> */ B(Nop),
+ /* 556 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(107),
+ /* 565 S> */ B(Nop),
+ /* 566 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(109),
+ /* 575 S> */ B(Nop),
+ /* 576 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(111),
+ /* 585 S> */ B(Nop),
+ /* 586 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(113),
+ /* 595 S> */ B(Nop),
+ /* 596 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(115),
+ /* 605 S> */ B(Nop),
+ /* 606 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(117),
+ /* 615 S> */ B(Nop),
+ /* 616 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(119),
+ /* 625 S> */ B(Nop),
+ /* 626 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(121),
+ /* 635 S> */ B(Nop),
+ /* 636 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(123),
+ /* 645 S> */ B(Nop),
+ /* 646 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(125),
+ /* 655 S> */ B(Nop),
+ /* 656 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(127),
+ /* 665 S> */ B(Nop),
+ /* 666 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(129),
+ /* 675 S> */ B(Nop),
+ /* 676 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(131),
+ /* 685 S> */ B(Nop),
+ /* 686 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(133),
+ /* 695 S> */ B(Nop),
+ /* 696 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(135),
+ /* 705 S> */ B(Nop),
+ /* 706 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(137),
+ /* 715 S> */ B(Nop),
+ /* 716 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(139),
+ /* 725 S> */ B(Nop),
+ /* 726 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(141),
+ /* 735 S> */ B(Nop),
+ /* 736 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(143),
+ /* 745 S> */ B(Nop),
+ /* 746 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(145),
+ /* 755 S> */ B(Nop),
+ /* 756 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(147),
+ /* 765 S> */ B(Nop),
+ /* 766 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(149),
+ /* 775 S> */ B(Nop),
+ /* 776 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(151),
+ /* 785 S> */ B(Nop),
+ /* 786 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(153),
+ /* 795 S> */ B(Nop),
+ /* 796 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(155),
+ /* 805 S> */ B(Nop),
+ /* 806 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(157),
+ /* 815 S> */ B(Nop),
+ /* 816 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(159),
+ /* 825 S> */ B(Nop),
+ /* 826 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(161),
+ /* 835 S> */ B(Nop),
+ /* 836 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(163),
+ /* 845 S> */ B(Nop),
+ /* 846 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(165),
+ /* 855 S> */ B(Nop),
+ /* 856 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(167),
+ /* 865 S> */ B(Nop),
+ /* 866 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(169),
+ /* 875 S> */ B(Nop),
+ /* 876 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(171),
+ /* 885 S> */ B(Nop),
+ /* 886 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(173),
+ /* 895 S> */ B(Nop),
+ /* 896 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(175),
+ /* 905 S> */ B(Nop),
+ /* 906 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(177),
+ /* 915 S> */ B(Nop),
+ /* 916 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(179),
+ /* 925 S> */ B(Nop),
+ /* 926 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(181),
+ /* 935 S> */ B(Nop),
+ /* 936 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(183),
+ /* 945 S> */ B(Nop),
+ /* 946 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(185),
+ /* 955 S> */ B(Nop),
+ /* 956 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(187),
+ /* 965 S> */ B(Nop),
+ /* 966 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(189),
+ /* 975 S> */ B(Nop),
+ /* 976 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(191),
+ /* 985 S> */ B(Nop),
+ /* 986 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(193),
+ /* 995 S> */ B(Nop),
+ /* 996 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(195),
+ /* 1005 S> */ B(Nop),
+ /* 1006 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(197),
+ /* 1015 S> */ B(Nop),
+ /* 1016 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(199),
+ /* 1025 S> */ B(Nop),
+ /* 1026 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(201),
+ /* 1035 S> */ B(Nop),
+ /* 1036 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(203),
+ /* 1045 S> */ B(Nop),
+ /* 1046 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(205),
+ /* 1055 S> */ B(Nop),
+ /* 1056 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(207),
+ /* 1065 S> */ B(Nop),
+ /* 1066 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(209),
+ /* 1075 S> */ B(Nop),
+ /* 1076 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(211),
+ /* 1085 S> */ B(Nop),
+ /* 1086 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(213),
+ /* 1095 S> */ B(Nop),
+ /* 1096 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(215),
+ /* 1105 S> */ B(Nop),
+ /* 1106 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(217),
+ /* 1115 S> */ B(Nop),
+ /* 1116 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(219),
+ /* 1125 S> */ B(Nop),
+ /* 1126 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(221),
+ /* 1135 S> */ B(Nop),
+ /* 1136 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(223),
+ /* 1145 S> */ B(Nop),
+ /* 1146 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(225),
+ /* 1155 S> */ B(Nop),
+ /* 1156 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(227),
+ /* 1165 S> */ B(Nop),
+ /* 1166 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(229),
+ /* 1175 S> */ B(Nop),
+ /* 1176 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(231),
+ /* 1185 S> */ B(Nop),
+ /* 1186 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(233),
+ /* 1195 S> */ B(Nop),
+ /* 1196 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(235),
+ /* 1205 S> */ B(Nop),
+ /* 1206 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(237),
+ /* 1215 S> */ B(Nop),
+ /* 1216 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(239),
+ /* 1225 S> */ B(Nop),
+ /* 1226 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(241),
+ /* 1235 S> */ B(Nop),
+ /* 1236 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(243),
+ /* 1245 S> */ B(Nop),
+ /* 1246 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(245),
+ /* 1255 S> */ B(Nop),
+ /* 1256 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(247),
+ /* 1265 S> */ B(Nop),
+ /* 1266 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(249),
+ /* 1275 S> */ B(Nop),
+ /* 1276 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(251),
+ /* 1285 S> */ B(Nop),
+ /* 1286 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(253),
+ /* 1295 S> */ B(Nop),
+ /* 1296 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(255),
/* 1305 S> */ B(LdaSmi), U8(2),
/* 1307 E> */ B(Wide), B(StaGlobalSloppy), U16(1), U16(257),
B(LdaUndefined),
@@ -769,395 +641,267 @@
}
f({name: 1});
"
-frame size: 1
+frame size: 0
parameter count: 2
-bytecode array length: 1035
+bytecode array length: 651
bytecodes: [
/* 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),
+ /* 41 S> */ B(Nop),
+ /* 42 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(1),
+ /* 51 S> */ B(Nop),
+ /* 52 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(3),
+ /* 61 S> */ B(Nop),
+ /* 62 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(5),
+ /* 71 S> */ B(Nop),
+ /* 72 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(7),
+ /* 81 S> */ B(Nop),
+ /* 82 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(9),
+ /* 91 S> */ B(Nop),
+ /* 92 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(11),
+ /* 101 S> */ B(Nop),
+ /* 102 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(13),
+ /* 111 S> */ B(Nop),
+ /* 112 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(15),
+ /* 121 S> */ B(Nop),
+ /* 122 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(17),
+ /* 131 S> */ B(Nop),
+ /* 132 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(19),
+ /* 141 S> */ B(Nop),
+ /* 142 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(21),
+ /* 151 S> */ B(Nop),
+ /* 152 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(23),
+ /* 161 S> */ B(Nop),
+ /* 162 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(25),
+ /* 171 S> */ B(Nop),
+ /* 172 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(27),
+ /* 181 S> */ B(Nop),
+ /* 182 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(29),
+ /* 191 S> */ B(Nop),
+ /* 192 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(31),
+ /* 201 S> */ B(Nop),
+ /* 202 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(33),
+ /* 211 S> */ B(Nop),
+ /* 212 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(35),
+ /* 221 S> */ B(Nop),
+ /* 222 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(37),
+ /* 231 S> */ B(Nop),
+ /* 232 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(39),
+ /* 241 S> */ B(Nop),
+ /* 242 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(41),
+ /* 251 S> */ B(Nop),
+ /* 252 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(43),
+ /* 261 S> */ B(Nop),
+ /* 262 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(45),
+ /* 271 S> */ B(Nop),
+ /* 272 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(47),
+ /* 281 S> */ B(Nop),
+ /* 282 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(49),
+ /* 291 S> */ B(Nop),
+ /* 292 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(51),
+ /* 301 S> */ B(Nop),
+ /* 302 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(53),
+ /* 311 S> */ B(Nop),
+ /* 312 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(55),
+ /* 321 S> */ B(Nop),
+ /* 322 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(57),
+ /* 331 S> */ B(Nop),
+ /* 332 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(59),
+ /* 341 S> */ B(Nop),
+ /* 342 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(61),
+ /* 351 S> */ B(Nop),
+ /* 352 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(63),
+ /* 361 S> */ B(Nop),
+ /* 362 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(65),
+ /* 371 S> */ B(Nop),
+ /* 372 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(67),
+ /* 381 S> */ B(Nop),
+ /* 382 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(69),
+ /* 391 S> */ B(Nop),
+ /* 392 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(71),
+ /* 401 S> */ B(Nop),
+ /* 402 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(73),
+ /* 411 S> */ B(Nop),
+ /* 412 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(75),
+ /* 421 S> */ B(Nop),
+ /* 422 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(77),
+ /* 431 S> */ B(Nop),
+ /* 432 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(79),
+ /* 441 S> */ B(Nop),
+ /* 442 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(81),
+ /* 451 S> */ B(Nop),
+ /* 452 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(83),
+ /* 461 S> */ B(Nop),
+ /* 462 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(85),
+ /* 471 S> */ B(Nop),
+ /* 472 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(87),
+ /* 481 S> */ B(Nop),
+ /* 482 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(89),
+ /* 491 S> */ B(Nop),
+ /* 492 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(91),
+ /* 501 S> */ B(Nop),
+ /* 502 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(93),
+ /* 511 S> */ B(Nop),
+ /* 512 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(95),
+ /* 521 S> */ B(Nop),
+ /* 522 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(97),
+ /* 531 S> */ B(Nop),
+ /* 532 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(99),
+ /* 541 S> */ B(Nop),
+ /* 542 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(101),
+ /* 551 S> */ B(Nop),
+ /* 552 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(103),
+ /* 561 S> */ B(Nop),
+ /* 562 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(105),
+ /* 571 S> */ B(Nop),
+ /* 572 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(107),
+ /* 581 S> */ B(Nop),
+ /* 582 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(109),
+ /* 591 S> */ B(Nop),
+ /* 592 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(111),
+ /* 601 S> */ B(Nop),
+ /* 602 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(113),
+ /* 611 S> */ B(Nop),
+ /* 612 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(115),
+ /* 621 S> */ B(Nop),
+ /* 622 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(117),
+ /* 631 S> */ B(Nop),
+ /* 632 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(119),
+ /* 641 S> */ B(Nop),
+ /* 642 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(121),
+ /* 651 S> */ B(Nop),
+ /* 652 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(123),
+ /* 661 S> */ B(Nop),
+ /* 662 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(125),
+ /* 671 S> */ B(Nop),
+ /* 672 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(127),
+ /* 681 S> */ B(Nop),
+ /* 682 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(129),
+ /* 691 S> */ B(Nop),
+ /* 692 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(131),
+ /* 701 S> */ B(Nop),
+ /* 702 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(133),
+ /* 711 S> */ B(Nop),
+ /* 712 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(135),
+ /* 721 S> */ B(Nop),
+ /* 722 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(137),
+ /* 731 S> */ B(Nop),
+ /* 732 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(139),
+ /* 741 S> */ B(Nop),
+ /* 742 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(141),
+ /* 751 S> */ B(Nop),
+ /* 752 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(143),
+ /* 761 S> */ B(Nop),
+ /* 762 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(145),
+ /* 771 S> */ B(Nop),
+ /* 772 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(147),
+ /* 781 S> */ B(Nop),
+ /* 782 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(149),
+ /* 791 S> */ B(Nop),
+ /* 792 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(151),
+ /* 801 S> */ B(Nop),
+ /* 802 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(153),
+ /* 811 S> */ B(Nop),
+ /* 812 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(155),
+ /* 821 S> */ B(Nop),
+ /* 822 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(157),
+ /* 831 S> */ B(Nop),
+ /* 832 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(159),
+ /* 841 S> */ B(Nop),
+ /* 842 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(161),
+ /* 851 S> */ B(Nop),
+ /* 852 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(163),
+ /* 861 S> */ B(Nop),
+ /* 862 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(165),
+ /* 871 S> */ B(Nop),
+ /* 872 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(167),
+ /* 881 S> */ B(Nop),
+ /* 882 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(169),
+ /* 891 S> */ B(Nop),
+ /* 892 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(171),
+ /* 901 S> */ B(Nop),
+ /* 902 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(173),
+ /* 911 S> */ B(Nop),
+ /* 912 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(175),
+ /* 921 S> */ B(Nop),
+ /* 922 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(177),
+ /* 931 S> */ B(Nop),
+ /* 932 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(179),
+ /* 941 S> */ B(Nop),
+ /* 942 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(181),
+ /* 951 S> */ B(Nop),
+ /* 952 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(183),
+ /* 961 S> */ B(Nop),
+ /* 962 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(185),
+ /* 971 S> */ B(Nop),
+ /* 972 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(187),
+ /* 981 S> */ B(Nop),
+ /* 982 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(189),
+ /* 991 S> */ B(Nop),
+ /* 992 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(191),
+ /* 1001 S> */ B(Nop),
+ /* 1002 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(193),
+ /* 1011 S> */ B(Nop),
+ /* 1012 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(195),
+ /* 1021 S> */ B(Nop),
+ /* 1022 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(197),
+ /* 1031 S> */ B(Nop),
+ /* 1032 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(199),
+ /* 1041 S> */ B(Nop),
+ /* 1042 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(201),
+ /* 1051 S> */ B(Nop),
+ /* 1052 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(203),
+ /* 1061 S> */ B(Nop),
+ /* 1062 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(205),
+ /* 1071 S> */ B(Nop),
+ /* 1072 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(207),
+ /* 1081 S> */ B(Nop),
+ /* 1082 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(209),
+ /* 1091 S> */ B(Nop),
+ /* 1092 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(211),
+ /* 1101 S> */ B(Nop),
+ /* 1102 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(213),
+ /* 1111 S> */ B(Nop),
+ /* 1112 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(215),
+ /* 1121 S> */ B(Nop),
+ /* 1122 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(217),
+ /* 1131 S> */ B(Nop),
+ /* 1132 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(219),
+ /* 1141 S> */ B(Nop),
+ /* 1142 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(221),
+ /* 1151 S> */ B(Nop),
+ /* 1152 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(223),
+ /* 1161 S> */ B(Nop),
+ /* 1162 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(225),
+ /* 1171 S> */ B(Nop),
+ /* 1172 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(227),
+ /* 1181 S> */ B(Nop),
+ /* 1182 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(229),
+ /* 1191 S> */ B(Nop),
+ /* 1192 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(231),
+ /* 1201 S> */ B(Nop),
+ /* 1202 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(233),
+ /* 1211 S> */ B(Nop),
+ /* 1212 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(235),
+ /* 1221 S> */ B(Nop),
+ /* 1222 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(237),
+ /* 1231 S> */ B(Nop),
+ /* 1232 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(239),
+ /* 1241 S> */ B(Nop),
+ /* 1242 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(241),
+ /* 1251 S> */ B(Nop),
+ /* 1252 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(243),
+ /* 1261 S> */ B(Nop),
+ /* 1262 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(245),
+ /* 1271 S> */ B(Nop),
+ /* 1272 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(247),
+ /* 1281 S> */ B(Nop),
+ /* 1282 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(249),
+ /* 1291 S> */ B(Nop),
+ /* 1292 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(251),
+ /* 1301 S> */ B(Nop),
+ /* 1302 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(253),
+ /* 1311 S> */ B(Nop),
+ /* 1312 E> */ B(LdaNamedProperty), R(arg0), U8(0), U8(255),
/* 1321 S> */ B(LdaSmi), U8(2),
/* 1323 E> */ B(Wide), B(StaGlobalStrict), U16(1), U16(257),
B(LdaUndefined),
diff --git a/test/cctest/interpreter/bytecode_expectations/StringConstants.golden b/test/cctest/interpreter/bytecode_expectations/StringConstants.golden
index a35df08..c28ac2a 100644
--- a/test/cctest/interpreter/bytecode_expectations/StringConstants.golden
+++ b/test/cctest/interpreter/bytecode_expectations/StringConstants.golden
@@ -35,7 +35,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 58 S> */ B(LdaConstant), U8(1),
/* 82 S> */ B(Return),
]
@@ -56,7 +56,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaConstant), U8(0),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 57 S> */ B(LdaConstant), U8(0),
/* 79 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/Switch.golden b/test/cctest/interpreter/bytecode_expectations/Switch.golden
index c252140..ddb8a7a 100644
--- a/test/cctest/interpreter/bytecode_expectations/Switch.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Switch.golden
@@ -17,16 +17,16 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 31
+bytecode array length: 32
bytecodes: [
/* 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(Star), R(1),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(0),
+ B(Mov), R(0), R(2),
+ B(JumpIfToBooleanTrue), U8(10),
B(LdaSmi), U8(2),
B(TestEqualStrict), R(2),
B(JumpIfTrue), U8(7),
@@ -53,25 +53,25 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 37
+bytecode array length: 38
bytecodes: [
/* 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(Star), R(1),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(0),
+ B(Mov), R(0), R(2),
+ B(JumpIfToBooleanTrue), 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),
+ B(Star), R(1),
/* 73 S> */ B(Jump), U8(8),
/* 89 S> */ B(LdaSmi), U8(3),
- /* 91 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 96 S> */ B(Jump), U8(2),
B(LdaUndefined),
/* 105 S> */ B(Return),
@@ -91,24 +91,24 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 35
+bytecode array length: 36
bytecodes: [
/* 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(Star), R(1),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(0),
+ B(Mov), R(0), R(2),
+ B(JumpIfToBooleanTrue), 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),
+ B(Star), R(1),
/* 98 S> */ B(LdaSmi), U8(3),
- /* 100 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 105 S> */ B(Jump), U8(2),
B(LdaUndefined),
/* 114 S> */ B(Return),
@@ -129,16 +129,16 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 35
+bytecode array length: 36
bytecodes: [
/* 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(Star), R(1),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(0),
+ B(Mov), R(0), R(2),
+ B(JumpIfToBooleanTrue), U8(10),
B(LdaSmi), U8(3),
B(TestEqualStrict), R(2),
B(JumpIfTrue), U8(6),
@@ -146,7 +146,7 @@
/* 66 S> */ B(Jump), U8(10),
/* 82 S> */ B(Jump), U8(8),
/* 99 S> */ B(LdaSmi), U8(1),
- /* 101 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 106 S> */ B(Jump), U8(2),
B(LdaUndefined),
/* 115 S> */ B(Return),
@@ -167,29 +167,29 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 44
+bytecode array length: 45
bytecodes: [
/* 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(Star), R(1),
+ /* 42 E> */ B(TypeOf),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(0),
+ B(Mov), R(0), R(2),
+ B(JumpIfToBooleanTrue), 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),
+ B(Star), R(1),
/* 81 S> */ B(Jump), U8(14),
/* 97 S> */ B(LdaSmi), U8(2),
- /* 99 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 104 S> */ B(Jump), U8(8),
/* 121 S> */ B(LdaSmi), U8(3),
- /* 123 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 128 S> */ B(Jump), U8(2),
B(LdaUndefined),
/* 137 S> */ B(Return),
@@ -209,23 +209,22 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 32
+bytecode array length: 31
bytecodes: [
/* 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(Star), R(1),
+ B(Star), R(0),
+ /* 45 S> */ B(TypeOf),
+ B(TestEqualStrict), R(0),
+ B(Mov), R(0), R(2),
+ B(JumpIfToBooleanTrue), U8(4),
B(Jump), U8(8),
/* 74 S> */ B(LdaSmi), U8(1),
- /* 76 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 81 S> */ B(Jump), U8(8),
/* 98 S> */ B(LdaSmi), U8(2),
- /* 100 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 105 S> */ B(Jump), U8(2),
B(LdaUndefined),
/* 114 S> */ B(Return),
@@ -312,151 +311,151 @@
"
frame size: 3
parameter count: 1
-bytecode array length: 289
+bytecode array length: 290
bytecodes: [
/* 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(Star), R(1),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(0),
+ B(Mov), R(0), R(2),
+ B(JumpIfToBooleanTrue), 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),
+ B(Star), R(1),
/* 77 S> */ B(LdaSmi), U8(2),
- /* 79 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 86 S> */ B(LdaSmi), U8(2),
- /* 88 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 95 S> */ B(LdaSmi), U8(2),
- /* 97 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 104 S> */ B(LdaSmi), U8(2),
- /* 106 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 113 S> */ B(LdaSmi), U8(2),
- /* 115 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 122 S> */ B(LdaSmi), U8(2),
- /* 124 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 131 S> */ B(LdaSmi), U8(2),
- /* 133 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 140 S> */ B(LdaSmi), U8(2),
- /* 142 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 149 S> */ B(LdaSmi), U8(2),
- /* 151 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 158 S> */ B(LdaSmi), U8(2),
- /* 160 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 167 S> */ B(LdaSmi), U8(2),
- /* 169 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 176 S> */ B(LdaSmi), U8(2),
- /* 178 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 185 S> */ B(LdaSmi), U8(2),
- /* 187 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 194 S> */ B(LdaSmi), U8(2),
- /* 196 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 203 S> */ B(LdaSmi), U8(2),
- /* 205 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 212 S> */ B(LdaSmi), U8(2),
- /* 214 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 221 S> */ B(LdaSmi), U8(2),
- /* 223 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 230 S> */ B(LdaSmi), U8(2),
- /* 232 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 239 S> */ B(LdaSmi), U8(2),
- /* 241 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 248 S> */ B(LdaSmi), U8(2),
- /* 250 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 257 S> */ B(LdaSmi), U8(2),
- /* 259 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 266 S> */ B(LdaSmi), U8(2),
- /* 268 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 275 S> */ B(LdaSmi), U8(2),
- /* 277 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 284 S> */ B(LdaSmi), U8(2),
- /* 286 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 293 S> */ B(LdaSmi), U8(2),
- /* 295 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 302 S> */ B(LdaSmi), U8(2),
- /* 304 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 311 S> */ B(LdaSmi), U8(2),
- /* 313 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 320 S> */ B(LdaSmi), U8(2),
- /* 322 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 329 S> */ B(LdaSmi), U8(2),
- /* 331 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 338 S> */ B(LdaSmi), U8(2),
- /* 340 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 347 S> */ B(LdaSmi), U8(2),
- /* 349 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 356 S> */ B(LdaSmi), U8(2),
- /* 358 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 365 S> */ B(LdaSmi), U8(2),
- /* 367 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 374 S> */ B(LdaSmi), U8(2),
- /* 376 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 383 S> */ B(LdaSmi), U8(2),
- /* 385 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 392 S> */ B(LdaSmi), U8(2),
- /* 394 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 401 S> */ B(LdaSmi), U8(2),
- /* 403 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 410 S> */ B(LdaSmi), U8(2),
- /* 412 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 419 S> */ B(LdaSmi), U8(2),
- /* 421 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 428 S> */ B(LdaSmi), U8(2),
- /* 430 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 437 S> */ B(LdaSmi), U8(2),
- /* 439 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 446 S> */ B(LdaSmi), U8(2),
- /* 448 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 455 S> */ B(LdaSmi), U8(2),
- /* 457 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 464 S> */ B(LdaSmi), U8(2),
- /* 466 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 473 S> */ B(LdaSmi), U8(2),
- /* 475 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 482 S> */ B(LdaSmi), U8(2),
- /* 484 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 491 S> */ B(LdaSmi), U8(2),
- /* 493 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 500 S> */ B(LdaSmi), U8(2),
- /* 502 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 509 S> */ B(LdaSmi), U8(2),
- /* 511 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 518 S> */ B(LdaSmi), U8(2),
- /* 520 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 527 S> */ B(LdaSmi), U8(2),
- /* 529 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 536 S> */ B(LdaSmi), U8(2),
- /* 538 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 545 S> */ B(LdaSmi), U8(2),
- /* 547 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 554 S> */ B(LdaSmi), U8(2),
- /* 556 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 563 S> */ B(LdaSmi), U8(2),
- /* 565 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 572 S> */ B(LdaSmi), U8(2),
- /* 574 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 581 S> */ B(LdaSmi), U8(2),
- /* 583 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 590 S> */ B(LdaSmi), U8(2),
- /* 592 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 599 S> */ B(LdaSmi), U8(2),
- /* 601 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 608 S> */ B(LdaSmi), U8(2),
- /* 610 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 617 S> */ B(LdaSmi), U8(2),
- /* 619 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 626 S> */ B(LdaSmi), U8(2),
- /* 628 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 635 S> */ B(LdaSmi), U8(2),
- /* 637 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 644 S> */ B(Jump), U8(8),
/* 662 S> */ B(LdaSmi), U8(3),
- /* 664 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 671 S> */ B(Jump), U8(2),
B(LdaUndefined),
/* 680 S> */ B(Return),
@@ -482,38 +481,36 @@
"
frame size: 5
parameter count: 1
-bytecode array length: 61
+bytecode array length: 59
bytecodes: [
/* 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(Star), R(2),
+ B(Star), R(0),
+ /* 45 S> */ B(LdaSmi), U8(1),
+ B(TestEqualStrict), R(0),
+ B(Mov), R(0), R(3),
+ B(JumpIfToBooleanTrue), 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(JumpIfTrue), U8(33),
+ B(Jump), U8(35),
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),
+ /* 77 E> */ B(Add), R(2),
+ B(Star), R(1),
+ /* 70 S> */ B(LdaSmi), U8(2),
+ B(TestEqualStrict), R(1),
+ B(Mov), R(1), R(4),
+ B(JumpIfToBooleanTrue), U8(4),
B(Jump), U8(8),
/* 101 S> */ B(LdaSmi), U8(1),
- /* 103 E> */ B(Star), R(2),
+ B(Star), R(2),
/* 108 S> */ B(Jump), U8(8),
/* 131 S> */ B(LdaSmi), U8(2),
- /* 133 E> */ B(Star), R(2),
+ B(Star), R(2),
/* 138 S> */ B(Jump), U8(2),
/* 176 S> */ B(LdaSmi), U8(3),
- /* 178 E> */ B(Star), R(2),
+ B(Star), R(2),
B(LdaUndefined),
/* 185 S> */ B(Return),
]
diff --git a/test/cctest/interpreter/bytecode_expectations/ThisFunction.golden b/test/cctest/interpreter/bytecode_expectations/ThisFunction.golden
index 5d7328b..582c087 100644
--- a/test/cctest/interpreter/bytecode_expectations/ThisFunction.golden
+++ b/test/cctest/interpreter/bytecode_expectations/ThisFunction.golden
@@ -16,11 +16,10 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 7
+bytecode array length: 6
bytecodes: [
/* 21 E> */ B(StackCheck),
- B(Ldar), R(closure),
- B(Star), R(0),
+ B(Mov), R(closure), R(0),
B(LdaUndefined),
/* 25 S> */ B(Return),
]
@@ -37,11 +36,11 @@
"
frame size: 1
parameter count: 1
-bytecode array length: 6
+bytecode array length: 7
bytecodes: [
/* 21 E> */ B(StackCheck),
- B(Ldar), R(closure),
- B(Star), R(0),
+ B(Mov), R(closure), R(0),
+ /* 26 S> */ B(Ldar), 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 7c671ac..4e7a0bc 100644
--- a/test/cctest/interpreter/bytecode_expectations/Throw.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Throw.golden
@@ -52,7 +52,7 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 45 S> */ B(JumpIfToBooleanFalse), U8(5),
/* 54 S> */ B(LdaConstant), U8(0),
/* 54 E> */ B(Throw),
diff --git a/test/cctest/interpreter/bytecode_expectations/TopLevelObjectLiterals.golden b/test/cctest/interpreter/bytecode_expectations/TopLevelObjectLiterals.golden
index e1d0ec3..00df0af 100644
--- a/test/cctest/interpreter/bytecode_expectations/TopLevelObjectLiterals.golden
+++ b/test/cctest/interpreter/bytecode_expectations/TopLevelObjectLiterals.golden
@@ -14,7 +14,7 @@
"
frame size: 5
parameter count: 1
-bytecode array length: 44
+bytecode array length: 43
bytecodes: [
B(LdaConstant), U8(0),
B(Star), R(1),
@@ -29,9 +29,8 @@
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(StaNamedPropertySloppy), R(4), U8(4), U8(3),
+ B(Mov), R(4), R(3),
B(CallRuntime), U16(Runtime::kInitializeVarGlobal), R(1), U8(3),
B(LdaUndefined),
/* 33 S> */ B(Return),
diff --git a/test/cctest/interpreter/bytecode_expectations/TryCatch.golden b/test/cctest/interpreter/bytecode_expectations/TryCatch.golden
index b57baf8..f061b70 100644
--- a/test/cctest/interpreter/bytecode_expectations/TryCatch.golden
+++ b/test/cctest/interpreter/bytecode_expectations/TryCatch.golden
@@ -13,17 +13,17 @@
"
frame size: 5
parameter count: 1
-bytecode array length: 40
+bytecode array length: 41
bytecodes: [
/* 30 E> */ B(StackCheck),
B(Mov), R(context), R(1),
/* 40 S> */ B(LdaSmi), U8(1),
/* 75 S> */ B(Return),
+ B(Jump), U8(32),
B(Star), R(3),
B(LdaConstant), U8(0),
B(Star), R(2),
- B(Ldar), R(closure),
- B(Star), R(4),
+ B(Mov), R(closure), R(4),
B(CallRuntime), U16(Runtime::kPushCatchContext), R(2), U8(3),
B(Star), R(1),
B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
@@ -39,7 +39,7 @@
"e",
]
handlers: [
- [4, 7, 7],
+ [4, 7, 9],
]
---
@@ -50,19 +50,18 @@
"
frame size: 6
parameter count: 1
-bytecode array length: 81
+bytecode array length: 79
bytecodes: [
/* 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(0),
+ B(Jump), U8(29),
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(Mov), R(closure), R(5),
+ /* 49 E> */ 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),
@@ -70,20 +69,19 @@
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(0),
+ B(Jump), U8(33),
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(Mov), R(closure), R(5),
+ /* 77 E> */ 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(Star), R(0),
B(PopContext), R(1),
B(LdaUndefined),
/* 103 S> */ B(Return),
@@ -94,6 +92,6 @@
]
handlers: [
[4, 8, 10],
- [41, 45, 47],
+ [40, 44, 46],
]
diff --git a/test/cctest/interpreter/bytecode_expectations/TryFinally.golden b/test/cctest/interpreter/bytecode_expectations/TryFinally.golden
index bd29e1a..de3bbf0 100644
--- a/test/cctest/interpreter/bytecode_expectations/TryFinally.golden
+++ b/test/cctest/interpreter/bytecode_expectations/TryFinally.golden
@@ -18,21 +18,21 @@
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ B(Star), R(0),
B(Mov), R(context), R(3),
/* 51 S> */ B(LdaSmi), U8(2),
- /* 53 E> */ B(Star), R(0),
+ 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),
+ /* 53 E> */ 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(Star), R(0),
+ /* 72 E> */ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(3), U8(1),
B(LdaZero),
B(TestEqualStrict), R(1),
B(JumpIfTrue), U8(4),
@@ -55,28 +55,27 @@
"
frame size: 9
parameter count: 1
-bytecode array length: 88
+bytecode array length: 87
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaSmi), U8(1),
- /* 42 E> */ B(Star), R(0),
+ 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(0),
+ B(Jump), U8(33),
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(Mov), R(closure), R(8),
+ /* 53 E> */ 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(Star), R(0),
B(PopContext), R(1),
B(LdaSmi), U8(-1),
B(Star), R(2),
@@ -84,11 +83,11 @@
B(Star), R(3),
B(LdaZero),
B(Star), R(2),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ /* 73 E> */ 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(Star), R(0),
+ /* 92 E> */ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(4), U8(1),
B(LdaZero),
B(TestEqualStrict), R(2),
B(JumpIfTrue), U8(4),
@@ -102,7 +101,7 @@
"e",
]
handlers: [
- [8, 49, 55],
+ [8, 48, 54],
[11, 15, 17],
]
@@ -114,41 +113,39 @@
"
frame size: 10
parameter count: 1
-bytecode array length: 121
+bytecode array length: 119
bytecodes: [
/* 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(0),
+ B(Jump), U8(33),
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(Mov), R(closure), R(9),
+ /* 57 E> */ 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(Star), R(0),
B(PopContext), R(1),
- B(Jump), U8(34),
+ B(Jump), U8(33),
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(Mov), R(closure), R(8),
+ /* 76 E> */ 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(Star), R(0),
B(PopContext), R(1),
B(LdaSmi), U8(-1),
B(Star), R(2),
@@ -156,11 +153,11 @@
B(Star), R(3),
B(LdaZero),
B(Star), R(2),
- B(CallRuntime), U16(Runtime::kInterpreterClearPendingMessage), R(0), U8(0),
+ /* 97 E> */ 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(Star), R(0),
+ /* 116 E> */ B(CallRuntime), U16(Runtime::kInterpreterSetPendingMessage), R(4), U8(1),
B(LdaZero),
B(TestEqualStrict), R(2),
B(JumpIfTrue), U8(4),
@@ -174,8 +171,8 @@
"e",
]
handlers: [
- [4, 82, 88],
- [7, 48, 50],
+ [4, 80, 86],
+ [7, 47, 49],
[10, 14, 16],
]
diff --git a/test/cctest/interpreter/bytecode_expectations/Typeof.golden b/test/cctest/interpreter/bytecode_expectations/Typeof.golden
index b0e80dd..1fe9354 100644
--- a/test/cctest/interpreter/bytecode_expectations/Typeof.golden
+++ b/test/cctest/interpreter/bytecode_expectations/Typeof.golden
@@ -22,7 +22,7 @@
bytecodes: [
/* 10 E> */ B(StackCheck),
/* 24 S> */ B(LdaSmi), U8(13),
- /* 24 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 29 S> */ B(TypeOf),
/* 47 S> */ B(Return),
]
@@ -41,15 +41,14 @@
"
frame size: 0
parameter count: 1
-bytecode array length: 6
+bytecode array length: 5
bytecodes: [
/* 22 E> */ B(StackCheck),
- /* 28 S> */ B(LdaGlobalInsideTypeof), U8(0), U8(1),
+ /* 28 S> */ B(LdaGlobalInsideTypeof), U8(1),
B(TypeOf),
/* 46 S> */ B(Return),
]
constant pool: [
- "x",
]
handlers: [
]
diff --git a/test/cctest/interpreter/bytecode_expectations/UnaryOperators.golden b/test/cctest/interpreter/bytecode_expectations/UnaryOperators.golden
index f253be9..dc2a930 100644
--- a/test/cctest/interpreter/bytecode_expectations/UnaryOperators.golden
+++ b/test/cctest/interpreter/bytecode_expectations/UnaryOperators.golden
@@ -15,26 +15,22 @@
}
return x;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 31
+bytecode array length: 23
bytecodes: [
/* 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(Star), R(0),
+ /* 54 S> */ B(LdaSmi), U8(10),
+ /* 54 E> */ B(TestEqual), R(0),
B(LogicalNot),
- B(JumpIfFalse), U8(15),
+ B(JumpIfFalse), U8(11),
/* 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),
+ /* 65 S> */ B(LdaSmi), U8(10),
+ B(Add), R(0),
+ B(Star), R(0),
+ B(Jump), U8(-14),
/* 79 S> */ B(Ldar), R(0),
/* 89 S> */ B(Return),
]
@@ -51,22 +47,20 @@
} while(x == false);
return x;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 22
+bytecode array length: 18
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 42 S> */ B(LdaFalse),
- /* 42 E> */ B(Star), R(0),
+ 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),
+ B(Star), R(0),
+ /* 74 S> */ B(LdaFalse),
+ /* 74 E> */ B(TestEqual), R(0),
+ B(JumpIfTrue), U8(-9),
/* 85 S> */ B(Ldar), R(0),
/* 95 S> */ B(Return),
]
@@ -80,16 +74,15 @@
var x = 101;
return void(x * 3);
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 13
+bytecode array length: 11
bytecodes: [
/* 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(Star), R(0),
+ /* 47 S> */ B(LdaSmi), U8(3),
+ B(Mul), R(0),
B(LdaUndefined),
/* 67 S> */ B(Return),
]
@@ -106,19 +99,19 @@
"
frame size: 4
parameter count: 1
-bytecode array length: 23
+bytecode array length: 22
bytecodes: [
/* 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(0),
+ /* 56 S> */ B(Nop),
+ /* 66 E> */ B(Mul), R(0),
B(Star), R(3),
B(LdaSmi), U8(1),
B(Sub), R(3),
- B(LdaUndefined),
- /* 56 E> */ B(Star), R(1),
+ B(LdrUndefined), R(1),
+ B(Ldar), R(1),
+ /* 74 S> */ B(Nop),
/* 84 S> */ B(Return),
]
constant pool: [
@@ -131,16 +124,15 @@
var x = 13;
return ~x;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 46 S> */ B(LdaSmi), U8(-1),
+ B(BitwiseXor), R(0),
/* 57 S> */ B(Return),
]
constant pool: [
@@ -153,16 +145,15 @@
var x = 13;
return +x;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 46 S> */ B(LdaSmi), U8(1),
+ B(Mul), R(0),
/* 57 S> */ B(Return),
]
constant pool: [
@@ -175,16 +166,15 @@
var x = 13;
return -x;
"
-frame size: 2
+frame size: 1
parameter count: 1
-bytecode array length: 12
+bytecode array length: 10
bytecodes: [
/* 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),
+ B(Star), R(0),
+ /* 46 S> */ B(LdaSmi), U8(-1),
+ B(Mul), R(0),
/* 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 2c23cce..717f323 100644
--- a/test/cctest/interpreter/bytecode_expectations/WideRegisters.golden
+++ b/test/cctest/interpreter/bytecode_expectations/WideRegisters.golden
@@ -171,11 +171,11 @@
"
frame size: 157
parameter count: 1
-bytecode array length: 8
+bytecode array length: 10
bytecodes: [
/* 30 E> */ B(StackCheck),
- /* 1494 S> */ B(Wide), B(Ldar), R16(127),
- /* 1497 E> */ B(Star), R(0),
+ /* 1494 S> */ B(Wide), B(Mov), R16(127), R16(0),
+ /* 1505 S> */ B(Ldar), R(0),
/* 1516 S> */ B(Return),
]
constant pool: [
@@ -347,11 +347,11 @@
"
frame size: 157
parameter count: 1
-bytecode array length: 10
+bytecode array length: 12
bytecodes: [
/* 30 E> */ B(StackCheck),
- /* 1494 S> */ B(Wide), B(Ldar), R16(126),
- /* 1499 E> */ B(Wide), B(Star), R16(127),
+ /* 1494 S> */ B(Wide), B(Mov), R16(126), R16(127),
+ /* 1507 S> */ B(Wide), B(Ldar), R16(127),
/* 1520 S> */ B(Return),
]
constant pool: [
@@ -521,15 +521,13 @@
if (x2 > 3) { return x129; }
return x128;
"
-frame size: 158
+frame size: 157
parameter count: 1
-bytecode array length: 25
+bytecode array length: 17
bytecodes: [
/* 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),
+ /* 1494 S> */ B(LdaSmi), U8(3),
+ /* 1501 E> */ B(TestGreaterThan), R(2),
B(JumpIfFalse), U8(7),
/* 1508 S> */ B(Wide), B(Ldar), R16(129),
/* 1536 S> */ B(Return),
@@ -705,24 +703,20 @@
if (x2 > 3) { return x0; }
return x129;
"
-frame size: 158
+frame size: 157
parameter count: 1
-bytecode array length: 48
+bytecode array length: 34
bytecodes: [
/* 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(Star), R(0),
+ /* 1506 S> */ B(LdaSmi), U8(3),
+ /* 1515 E> */ B(Wide), B(TestEqual), R16(129),
+ B(JumpIfFalse), U8(10),
+ /* 1534 S> */ B(Wide), B(Mov), R16(0), R16(129),
+ B(Ldar), R(0),
+ /* 1540 S> */ B(LdaSmi), U8(3),
+ /* 1547 E> */ B(TestGreaterThan), R(2),
B(JumpIfFalse), U8(5),
/* 1554 S> */ B(Ldar), R(0),
/* 1580 S> */ B(Return),
@@ -899,32 +893,29 @@
"
frame size: 158
parameter count: 1
-bytecode array length: 66
+bytecode array length: 56
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 1503 S> */ B(LdaZero),
- /* 1503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1515 S> */ B(LdaZero),
- /* 1515 E> */ B(Star), R(1),
+ 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),
+ B(Wide), B(Star), R16(128),
+ /* 1538 S> */ B(LdaSmi), U8(64),
+ /* 1538 E> */ B(Wide), B(TestLessThan), R16(128),
+ B(JumpIfFalse), U8(33),
/* 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),
+ /* 1555 S> */ B(Wide), B(Ldar), R16(128),
+ /* 1561 E> */ B(Add), R(1),
+ B(Wide), B(Mov), R16(1), R16(157),
+ 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),
+ B(Wide), B(Star), R16(128),
+ B(Jump), U8(-37),
/* 1567 S> */ B(Wide), B(Ldar), R16(128),
/* 1580 S> */ B(Return),
]
@@ -1098,35 +1089,34 @@
"
frame size: 163
parameter count: 1
-bytecode array length: 84
+bytecode array length: 82
bytecodes: [
/* 30 E> */ B(StackCheck),
/* 1503 S> */ B(Wide), B(LdaSmi), U16(1234),
- /* 1503 E> */ B(Star), R(0),
+ B(Star), R(0),
/* 1518 S> */ B(LdaZero),
- /* 1518 E> */ B(Star), R(1),
+ B(Star), R(1),
/* 1534 S> */ B(Ldar), R(0),
- B(JumpIfUndefined), U8(69),
- B(JumpIfNull), U8(67),
+ B(JumpIfUndefined), U8(67),
+ B(JumpIfNull), U8(65),
B(ToObject),
- B(Wide), B(Star), R16(157),
B(Wide), B(ForInPrepare), R16(158),
+ B(Wide), B(Star), R16(157),
B(LdaZero),
B(Wide), B(Star), R16(161),
/* 1526 S> */ B(Wide), B(ForInDone), R16(161), R16(160),
- B(JumpIfTrue), U8(45),
+ B(JumpIfTrue), U8(43),
B(Wide), B(ForInNext), R16(157), R16(161), R16(158), U16(1),
- B(JumpIfUndefined), U8(23),
+ B(JumpIfUndefined), U8(21),
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),
+ /* 1541 S> */ B(Wide), B(Ldar), R16(128),
+ /* 1547 E> */ B(Add), R(1),
+ B(Wide), B(Mov), R16(1), R16(162),
+ B(Star), R(1),
+ /* 1544 E> */ B(Wide), B(ForInStep), R16(161),
B(Wide), B(Star), R16(161),
- B(Jump), U8(-49),
+ B(Jump), U8(-47),
/* 1553 S> */ B(Ldar), R(1),
/* 1564 S> */ B(Return),
]
@@ -1301,21 +1291,17 @@
"
frame size: 159
parameter count: 1
-bytecode array length: 55
+bytecode array length: 53
bytecodes: [
/* 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),
+ /* 1494 S> */ B(Wide), B(Mov), R16(64), R16(157),
+ B(Wide), B(Mov), R16(63), R16(158),
+ /* 1509 E> */ B(Wide), B(CallRuntime), U16(Runtime::kAdd), R16(157), U16(2),
+ B(Star), R(0),
+ /* 1515 S> */ B(Wide), B(Mov), R16(27), R16(157),
+ B(Wide), B(Mov), R16(143), R16(158),
+ /* 1530 E> */ B(Wide), B(CallRuntime), U16(Runtime::kAdd), R16(157), U16(2),
+ 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),
diff --git a/test/cctest/interpreter/bytecode_expectations/WithStatement.golden b/test/cctest/interpreter/bytecode_expectations/WithStatement.golden
index e1b7eda..71183de 100644
--- a/test/cctest/interpreter/bytecode_expectations/WithStatement.golden
+++ b/test/cctest/interpreter/bytecode_expectations/WithStatement.golden
@@ -13,15 +13,14 @@
"
frame size: 4
parameter count: 1
-bytecode array length: 26
+bytecode array length: 25
bytecodes: [
/* 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(Mov), R(closure), R(3),
B(CallRuntime), U16(Runtime::kPushWithContext), R(2), U8(2),
B(PushContext), R(0),
/* 50 S> */ B(LdaLookupSlot), U8(1),
diff --git a/test/cctest/interpreter/generate-bytecode-expectations.cc b/test/cctest/interpreter/generate-bytecode-expectations.cc
index f3dfd06..53f2e3f 100644
--- a/test/cctest/interpreter/generate-bytecode-expectations.cc
+++ b/test/cctest/interpreter/generate-bytecode-expectations.cc
@@ -358,7 +358,7 @@
i::FLAG_always_opt = false;
i::FLAG_allow_natives_syntax = true;
- v8::V8::InitializeICU();
+ v8::V8::InitializeICUDefaultLocation(exec_path);
v8::V8::InitializeExternalStartupData(exec_path);
v8::V8::InitializePlatform(platform_.get());
v8::V8::Initialize();
diff --git a/test/cctest/interpreter/interpreter-tester.h b/test/cctest/interpreter/interpreter-tester.h
index f8a0a8a..4e202ea 100644
--- a/test/cctest/interpreter/interpreter-tester.h
+++ b/test/cctest/interpreter/interpreter-tester.h
@@ -114,7 +114,7 @@
function->shared()->set_function_data(*bytecode_.ToHandleChecked());
}
if (!feedback_vector_.is_null()) {
- function->shared()->set_feedback_vector(
+ function->literals()->set_feedback_vector(
*feedback_vector_.ToHandleChecked());
}
return function;
diff --git a/test/cctest/interpreter/source-position-matcher.cc b/test/cctest/interpreter/source-position-matcher.cc
new file mode 100644
index 0000000..122f2c8
--- /dev/null
+++ b/test/cctest/interpreter/source-position-matcher.cc
@@ -0,0 +1,225 @@
+// 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 "test/cctest/interpreter/source-position-matcher.h"
+
+#include "src/objects-inl.h"
+#include "src/objects.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+// Comparer for PositionTableEntry instances.
+struct PositionTableEntryComparer {
+ bool operator()(const PositionTableEntry& lhs,
+ const PositionTableEntry& rhs) const {
+ int lhs_type_score = type_score(lhs);
+ int rhs_type_score = type_score(rhs);
+ if (lhs_type_score == rhs_type_score) {
+ return lhs.source_position < rhs.source_position;
+ } else {
+ return lhs_type_score < rhs_type_score;
+ }
+ }
+
+ int type_score(const PositionTableEntry& entry) const {
+ return entry.is_statement ? 1 : 0;
+ }
+};
+
+//
+// The principles for comparing source positions in bytecode arrays
+// are:
+//
+// 1. The number of statement positions must be the same in both.
+//
+// 2. Statement positions may be moved provide they do not affect the
+// debuggers causal view of the v8 heap and local state. This means
+// statement positions may be moved when their initial position is
+// on bytecodes that manipulate the accumulator and temporary
+// registers.
+//
+// 3. When duplicate expression positions are present, either may
+// be dropped.
+//
+// 4. Expression positions may be applied to later bytecodes in the
+// bytecode array if the current bytecode does not throw.
+//
+// 5. Expression positions may be dropped when they are applied to
+// bytecodes that manipulate local frame state and immediately
+// proceeded by another source position.
+//
+// 6. The relative ordering of source positions must be preserved.
+//
+bool SourcePositionMatcher::Match(Handle<BytecodeArray> original_bytecode,
+ Handle<BytecodeArray> optimized_bytecode) {
+ SourcePositionTableIterator original(
+ original_bytecode->source_position_table());
+ SourcePositionTableIterator optimized(
+ optimized_bytecode->source_position_table());
+
+ int last_original_bytecode_offset = 0;
+ int last_optimized_bytecode_offset = 0;
+
+ // Ordered lists of expression positions immediately before the
+ // latest statements in each bytecode array.
+ std::vector<PositionTableEntry> original_expression_entries;
+ std::vector<PositionTableEntry> optimized_expression_entries;
+
+ while (true) {
+ MoveToNextStatement(&original, &original_expression_entries);
+ MoveToNextStatement(&optimized, &optimized_expression_entries);
+
+ if (original.done() && optimized.done()) {
+ return true;
+ } else if (original.done()) {
+ return false;
+ } else if (optimized.done()) {
+ return false;
+ }
+
+ if (HasNewExpressionPositionsInOptimized(&original_expression_entries,
+ &optimized_expression_entries)) {
+ return false;
+ }
+
+ StripUnneededExpressionPositions(original_bytecode,
+ &original_expression_entries,
+ original.bytecode_offset());
+ StripUnneededExpressionPositions(optimized_bytecode,
+ &optimized_expression_entries,
+ optimized.bytecode_offset());
+
+ if (!CompareExpressionPositions(&original_expression_entries,
+ &optimized_expression_entries)) {
+ // Message logged in CompareExpressionPositions().
+ return false;
+ }
+
+ // Check original and optimized have matching source positions.
+ if (original.source_position() != optimized.source_position()) {
+ return false;
+ }
+
+ if (original.bytecode_offset() < last_original_bytecode_offset) {
+ return false;
+ }
+ last_original_bytecode_offset = original.bytecode_offset();
+
+ if (optimized.bytecode_offset() < last_optimized_bytecode_offset) {
+ return false;
+ }
+ last_optimized_bytecode_offset = optimized.bytecode_offset();
+
+ // TODO(oth): Can we compare statement positions are semantically
+ // equivalent? e.g. before a bytecode that has debugger observable
+ // effects. This is likely non-trivial.
+ }
+
+ return true;
+}
+
+bool SourcePositionMatcher::HasNewExpressionPositionsInOptimized(
+ const std::vector<PositionTableEntry>* const original_positions,
+ const std::vector<PositionTableEntry>* const optimized_positions) {
+ std::set<PositionTableEntry, PositionTableEntryComparer> original_set(
+ original_positions->begin(), original_positions->end());
+
+ bool retval = false;
+ for (auto optimized_position : *optimized_positions) {
+ if (original_set.find(optimized_position) == original_set.end()) {
+ retval = true;
+ }
+ }
+ return retval;
+}
+
+bool SourcePositionMatcher::CompareExpressionPositions(
+ const std::vector<PositionTableEntry>* const original_positions,
+ const std::vector<PositionTableEntry>* const optimized_positions) {
+ if (original_positions->size() != optimized_positions->size()) {
+ return false;
+ }
+
+ if (original_positions->size() == 0) {
+ return true;
+ }
+
+ for (size_t i = 0; i < original_positions->size(); ++i) {
+ PositionTableEntry original = original_positions->at(i);
+ PositionTableEntry optimized = original_positions->at(i);
+ CHECK(original.source_position > 0);
+ if ((original.is_statement || optimized.is_statement) ||
+ (original.source_position != optimized.source_position) ||
+ (original.source_position < 0)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+void SourcePositionMatcher::StripUnneededExpressionPositions(
+ Handle<BytecodeArray> bytecode_array,
+ std::vector<PositionTableEntry>* expression_positions,
+ int next_statement_bytecode_offset) {
+ size_t j = 0;
+ for (size_t i = 0; i < expression_positions->size(); ++i) {
+ CHECK(expression_positions->at(i).source_position > 0 &&
+ !expression_positions->at(i).is_statement);
+ int bytecode_end = (i == expression_positions->size() - 1)
+ ? next_statement_bytecode_offset
+ : expression_positions->at(i + 1).bytecode_offset;
+ if (ExpressionPositionIsNeeded(bytecode_array,
+ expression_positions->at(i).bytecode_offset,
+ bytecode_end)) {
+ expression_positions->at(j++) = expression_positions->at(i);
+ }
+ }
+ expression_positions->resize(j);
+}
+
+void SourcePositionMatcher::AdvanceBytecodeIterator(
+ BytecodeArrayIterator* iterator, int bytecode_offset) {
+ while (iterator->current_offset() != bytecode_offset) {
+ iterator->Advance();
+ }
+}
+
+bool SourcePositionMatcher::ExpressionPositionIsNeeded(
+ Handle<BytecodeArray> bytecode_array, int start_offset, int end_offset) {
+ CHECK_GT(end_offset, start_offset);
+ BytecodeArrayIterator iterator(bytecode_array);
+ AdvanceBytecodeIterator(&iterator, start_offset);
+
+ while (iterator.current_offset() != end_offset) {
+ if (Bytecodes::IsWithoutExternalSideEffects(iterator.current_bytecode())) {
+ iterator.Advance();
+ } else {
+ // Bytecode could throw so need an expression position.
+ return true;
+ }
+ }
+ return false;
+}
+
+void SourcePositionMatcher::MoveToNextStatement(
+ SourcePositionTableIterator* iterator,
+ std::vector<PositionTableEntry>* positions) {
+ iterator->Advance();
+ positions->clear();
+ while (!iterator->done()) {
+ if (iterator->is_statement()) {
+ break;
+ }
+ positions->push_back({iterator->bytecode_offset(),
+ iterator->source_position(),
+ iterator->is_statement()});
+ iterator->Advance();
+ }
+}
+
+} // namespace interpreter
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/interpreter/source-position-matcher.h b/test/cctest/interpreter/source-position-matcher.h
new file mode 100644
index 0000000..0bb5bed
--- /dev/null
+++ b/test/cctest/interpreter/source-position-matcher.h
@@ -0,0 +1,50 @@
+// 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.
+
+#ifndef TEST_CCTEST_INTERPRETER_SOURCE_POSITION_COMPARER_H_
+#define TEST_CCTEST_INTERPRETER_SOURCE_POSITION_COMPARER_H_
+
+#include "src/interpreter/bytecode-array-iterator.h"
+#include "src/interpreter/source-position-table.h"
+#include "src/objects.h"
+#include "src/v8.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+class SourcePositionMatcher final {
+ public:
+ bool Match(Handle<BytecodeArray> original, Handle<BytecodeArray> optimized);
+
+ private:
+ bool HasNewExpressionPositionsInOptimized(
+ const std::vector<PositionTableEntry>* const original_positions,
+ const std::vector<PositionTableEntry>* const optimized_positions);
+
+ bool CompareExpressionPositions(
+ const std::vector<PositionTableEntry>* const original_positions,
+ const std::vector<PositionTableEntry>* const optimized_positions);
+
+ void StripUnneededExpressionPositions(
+ Handle<BytecodeArray> bytecode_array,
+ std::vector<PositionTableEntry>* positions,
+ int next_statement_bytecode_offset);
+
+ bool ExpressionPositionIsNeeded(Handle<BytecodeArray> bytecode_array,
+ int start_offset, int end_offset);
+
+ void MoveToNextStatement(
+ SourcePositionTableIterator* iterator,
+ std::vector<PositionTableEntry>* expression_positions);
+
+ void AdvanceBytecodeIterator(BytecodeArrayIterator* iterator,
+ int bytecode_offset);
+};
+
+} // namespace interpreter
+} // namespace internal
+} // namespace v8
+
+#endif // TEST_CCTEST_INTERPRETER_SOURCE_POSITION_COMPARER_H_
diff --git a/test/cctest/interpreter/test-bytecode-generator.cc b/test/cctest/interpreter/test-bytecode-generator.cc
index 3d0fe6f..401ea14 100644
--- a/test/cctest/interpreter/test-bytecode-generator.cc
+++ b/test/cctest/interpreter/test-bytecode-generator.cc
@@ -2232,11 +2232,14 @@
printer.set_test_function_name("f");
const char* snippets[] = {
- "function* f() { }\n",
+ "function* f() { }\n"
+ "f();\n",
- "function* f() { yield 42 }\n",
+ "function* f() { yield 42 }\n"
+ "f();\n",
- "function* f() { for (let x of [42]) yield x }\n",
+ "function* f() { for (let x of [42]) yield x }\n"
+ "f();\n",
};
CHECK(CompareTexts(BuildActual(printer, snippets),
diff --git a/test/cctest/interpreter/test-interpreter-intrinsics.cc b/test/cctest/interpreter/test-interpreter-intrinsics.cc
index e4cf809..b8fce7a 100644
--- a/test/cctest/interpreter/test-interpreter-intrinsics.cc
+++ b/test/cctest/interpreter/test-interpreter-intrinsics.cc
@@ -29,7 +29,7 @@
builder.CallRuntime(function_id_, builder.Parameter(0), sizeof...(args))
.Return();
InterpreterTester tester(isolate_, builder.ToBytecodeArray());
- auto callable = tester.GetCallable<Handle<Object>>();
+ auto callable = tester.GetCallable<A...>();
return callable(args...).ToHandleChecked();
}
@@ -91,6 +91,189 @@
CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("42")));
}
+TEST(IsJSProxy) {
+ HandleAndZoneScope handles;
+
+ InvokeIntrinsicHelper helper(handles.main_isolate(), handles.main_zone(),
+ Runtime::kInlineIsJSProxy);
+ Factory* factory = handles.main_isolate()->factory();
+
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("new Date()")));
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("(function() {})")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("([1])")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("({})")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("(/x/)")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.Undefined()));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.Null()));
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("'string'")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("42")));
+ CHECK_EQ(*factory->true_value(),
+ *helper.Invoke(helper.NewObject("new Proxy({},{})")));
+}
+
+TEST(IsRegExp) {
+ HandleAndZoneScope handles;
+
+ InvokeIntrinsicHelper helper(handles.main_isolate(), handles.main_zone(),
+ Runtime::kInlineIsRegExp);
+ Factory* factory = handles.main_isolate()->factory();
+
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("new Date()")));
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("(function() {})")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("([1])")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("({})")));
+ CHECK_EQ(*factory->true_value(), *helper.Invoke(helper.NewObject("(/x/)")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.Undefined()));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.Null()));
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("'string'")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("42")));
+}
+
+TEST(IsTypedArray) {
+ HandleAndZoneScope handles;
+
+ InvokeIntrinsicHelper helper(handles.main_isolate(), handles.main_zone(),
+ Runtime::kInlineIsTypedArray);
+ Factory* factory = handles.main_isolate()->factory();
+
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("new Date()")));
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("(function() {})")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("([1])")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("({})")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("(/x/)")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.Undefined()));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.Null()));
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("'string'")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("42")));
+
+ CHECK_EQ(
+ *factory->true_value(),
+ *helper.Invoke(helper.NewObject("new Uint8Array(new ArrayBuffer(1));")));
+ CHECK_EQ(
+ *factory->true_value(),
+ *helper.Invoke(helper.NewObject("new Uint16Array(new ArrayBuffer(2));")));
+ CHECK_EQ(
+ *factory->true_value(),
+ *helper.Invoke(helper.NewObject("new Int32Array(new ArrayBuffer(4));")));
+}
+
+TEST(IsSmi) {
+ HandleAndZoneScope handles;
+
+ InvokeIntrinsicHelper helper(handles.main_isolate(), handles.main_zone(),
+ Runtime::kInlineIsSmi);
+ Factory* factory = handles.main_isolate()->factory();
+
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("new Date()")));
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("(function() {})")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("([1])")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("({})")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("(/x/)")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.Undefined()));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.Null()));
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("'string'")));
+ CHECK_EQ(*factory->false_value(), *helper.Invoke(helper.NewObject("42.2")));
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("4294967297")));
+ CHECK_EQ(*factory->true_value(), *helper.Invoke(helper.NewObject("42")));
+}
+
+TEST(Call) {
+ HandleAndZoneScope handles;
+ Isolate* isolate = handles.main_isolate();
+ Factory* factory = isolate->factory();
+ InvokeIntrinsicHelper helper(isolate, handles.main_zone(),
+ Runtime::kInlineCall);
+
+ CHECK_EQ(Smi::FromInt(20),
+ *helper.Invoke(helper.NewObject("(function() { return this.x; })"),
+ helper.NewObject("({ x: 20 })")));
+ CHECK_EQ(Smi::FromInt(50),
+ *helper.Invoke(helper.NewObject("(function(arg1) { return arg1; })"),
+ factory->undefined_value(),
+ handle(Smi::FromInt(50), isolate)));
+ CHECK_EQ(
+ Smi::FromInt(20),
+ *helper.Invoke(
+ helper.NewObject("(function(a, b, c) { return a + b + c; })"),
+ factory->undefined_value(), handle(Smi::FromInt(10), isolate),
+ handle(Smi::FromInt(7), isolate), handle(Smi::FromInt(3), isolate)));
+}
+
+TEST(IntrinsicAsStubCall) {
+ HandleAndZoneScope handles;
+ Isolate* isolate = handles.main_isolate();
+ Factory* factory = isolate->factory();
+ InvokeIntrinsicHelper to_number_helper(isolate, handles.main_zone(),
+ Runtime::kInlineToNumber);
+ CHECK_EQ(Smi::FromInt(46),
+ *to_number_helper.Invoke(to_number_helper.NewObject("'46'")));
+
+ InvokeIntrinsicHelper to_integer_helper(isolate, handles.main_zone(),
+ Runtime::kInlineToInteger);
+ CHECK_EQ(Smi::FromInt(502),
+ *to_integer_helper.Invoke(to_integer_helper.NewObject("502.67")));
+
+ InvokeIntrinsicHelper math_pow_helper(isolate, handles.main_zone(),
+ Runtime::kInlineMathPow);
+ CHECK(math_pow_helper
+ .Invoke(math_pow_helper.NewObject("3"),
+ math_pow_helper.NewObject("7"))
+ ->SameValue(Smi::FromInt(2187)));
+
+ InvokeIntrinsicHelper has_property_helper(isolate, handles.main_zone(),
+ Runtime::kInlineHasProperty);
+ CHECK_EQ(*factory->true_value(),
+ *has_property_helper.Invoke(
+ has_property_helper.NewObject("'x'"),
+ has_property_helper.NewObject("({ x: 20 })")));
+ CHECK_EQ(*factory->false_value(),
+ *has_property_helper.Invoke(
+ has_property_helper.NewObject("'y'"),
+ has_property_helper.NewObject("({ x: 20 })")));
+
+ InvokeIntrinsicHelper sub_string_helper(isolate, handles.main_zone(),
+ Runtime::kInlineSubString);
+ CHECK(sub_string_helper
+ .Invoke(sub_string_helper.NewObject("'foobar'"),
+ sub_string_helper.NewObject("3"),
+ sub_string_helper.NewObject("6"))
+ ->SameValue(*sub_string_helper.NewObject("'bar'")));
+}
+
+TEST(ValueOf) {
+ HandleAndZoneScope handles;
+ Isolate* isolate = handles.main_isolate();
+ Factory* factory = isolate->factory();
+ InvokeIntrinsicHelper helper(handles.main_isolate(), handles.main_zone(),
+ Runtime::kInlineValueOf);
+
+ CHECK_EQ(Smi::FromInt(1234), *helper.Invoke(helper.NewObject("1234")));
+ CHECK_EQ(Smi::FromInt(5678),
+ *helper.Invoke(helper.NewObject("new Object(5678)")));
+
+ CHECK_EQ(*factory->true_value(), *helper.Invoke(helper.NewObject("true")));
+ CHECK_EQ(*factory->false_value(),
+ *helper.Invoke(helper.NewObject("new Object(false)")));
+
+ CHECK(helper.Invoke(helper.NewObject("'foobar'"))
+ ->SameValue(*helper.NewObject("'foobar'")));
+ CHECK(helper.Invoke(helper.NewObject("new Object('foobar')"))
+ ->SameValue(*helper.NewObject("'foobar'")));
+}
+
} // namespace interpreter
} // namespace internal
} // namespace v8
diff --git a/test/cctest/interpreter/test-interpreter.cc b/test/cctest/interpreter/test-interpreter.cc
index acc93c5..07a22b7 100644
--- a/test/cctest/interpreter/test-interpreter.cc
+++ b/test/cctest/interpreter/test-interpreter.cc
@@ -8,6 +8,7 @@
#include "src/handles.h"
#include "src/interpreter/bytecode-array-builder.h"
#include "src/interpreter/bytecode-array-iterator.h"
+#include "src/interpreter/bytecode-label.h"
#include "src/interpreter/interpreter.h"
#include "test/cctest/cctest.h"
#include "test/cctest/interpreter/interpreter-tester.h"
@@ -138,6 +139,7 @@
{
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 0);
+
builder.LoadLiteral(Smi::FromInt(0x12345678)).Return();
Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
@@ -151,6 +153,7 @@
{
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 0);
+
builder.LoadLiteral(factory->NewHeapNumber(-2.1e19)).Return();
Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
@@ -164,6 +167,7 @@
{
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 0);
+
Handle<i::String> string = factory->NewStringFromAsciiChecked("String");
builder.LoadLiteral(string).Return();
Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
@@ -182,6 +186,7 @@
for (int i = 0; i <= kMaxInt8; i++) {
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, i + 1);
+
Register reg(i);
builder.LoadTrue()
.StoreAccumulatorInRegister(reg)
@@ -297,6 +302,7 @@
i::Factory* factory = handles.main_isolate()->factory();
BytecodeArrayBuilder builder(handles.main_isolate(),
handles.main_zone(), 1, 0, 1);
+
Register reg(0);
int lhs = lhs_inputs[l];
int rhs = rhs_inputs[r];
@@ -387,6 +393,7 @@
for (size_t i = 0; i < arraysize(test_cases); i++) {
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 1);
+
Register reg(0);
builder.LoadLiteral(test_cases[i].lhs)
.StoreAccumulatorInRegister(reg)
@@ -407,6 +414,7 @@
HandleAndZoneScope handles;
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 0);
+
builder.LoadAccumulatorWithRegister(builder.Parameter(0)).Return();
Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
@@ -429,6 +437,7 @@
HandleAndZoneScope handles;
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 8,
0, 0);
+
builder.LoadAccumulatorWithRegister(builder.Parameter(0))
.BinaryOperation(Token::Value::ADD, builder.Parameter(1))
.BinaryOperation(Token::Value::ADD, builder.Parameter(2))
@@ -464,6 +473,7 @@
HandleAndZoneScope handles;
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 0);
+
builder.LoadLiteral(Smi::FromInt(5))
.StoreAccumulatorInRegister(builder.Parameter(0))
.LoadAccumulatorWithRegister(builder.Parameter(0))
@@ -592,6 +602,7 @@
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 0);
+
builder.LoadNamedProperty(builder.Parameter(0), name, vector->GetIndex(slot))
.Return();
Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
@@ -645,6 +656,7 @@
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 1);
+
builder.LoadLiteral(key)
.LoadKeyedProperty(builder.Parameter(0), vector->GetIndex(slot))
.Return();
@@ -687,6 +699,7 @@
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 0);
+
builder.LoadLiteral(Smi::FromInt(999))
.StoreNamedProperty(builder.Parameter(0), name, vector->GetIndex(slot),
i::STRICT)
@@ -746,6 +759,7 @@
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 1);
+
builder.LoadLiteral(name)
.StoreAccumulatorInRegister(Register(0))
.LoadLiteral(Smi::FromInt(999))
@@ -796,6 +810,7 @@
{
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 1);
+
builder.LoadNamedProperty(builder.Parameter(0), name, slot_index)
.StoreAccumulatorInRegister(Register(0))
.Call(Register(0), builder.Parameter(0), 1, 0, tail_call_mode)
@@ -815,6 +830,7 @@
{
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 1);
+
builder.LoadNamedProperty(builder.Parameter(0), name, slot_index)
.StoreAccumulatorInRegister(Register(0))
.Call(Register(0), builder.Parameter(0), 1, 0, tail_call_mode)
@@ -837,6 +853,7 @@
{
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 4);
+
builder.LoadNamedProperty(builder.Parameter(0), name, slot_index)
.StoreAccumulatorInRegister(Register(0))
.LoadAccumulatorWithRegister(builder.Parameter(0))
@@ -864,6 +881,7 @@
{
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 12);
+
builder.LoadNamedProperty(builder.Parameter(0), name, slot_index)
.StoreAccumulatorInRegister(Register(0))
.LoadAccumulatorWithRegister(builder.Parameter(0))
@@ -938,6 +956,7 @@
HandleAndZoneScope handles;
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 0,
0, 2);
+
Register reg(0), scratch(1);
BytecodeLabel label[3];
@@ -965,6 +984,7 @@
HandleAndZoneScope handles;
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 0,
0, 2);
+
Register reg(0), scratch(1);
BytecodeLabel label[2];
BytecodeLabel done, done1;
@@ -998,6 +1018,7 @@
HandleAndZoneScope handles;
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 0,
0, 2);
+
Register reg(0), scratch(1);
BytecodeLabel label[2];
BytecodeLabel done, done1;
@@ -1030,8 +1051,9 @@
HandleAndZoneScope handles;
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 257);
+
Register reg(0), scratch(256);
- BytecodeLabel done;
+ BytecodeLabel done, fake;
builder.LoadLiteral(Smi::FromInt(0));
builder.StoreAccumulatorInRegister(reg);
@@ -1044,6 +1066,7 @@
builder.Jump(&done);
// Emit more than 16-bit immediate operands worth of code to jump over.
+ builder.Bind(&fake);
for (int i = 0; i < 6600; i++) {
builder.LoadLiteral(Smi::FromInt(0)); // 1-byte
builder.BinaryOperation(Token::Value::ADD, scratch); // 4-bytes
@@ -1167,6 +1190,7 @@
HandleAndZoneScope handles;
BytecodeArrayBuilder builder(handles.main_isolate(),
handles.main_zone(), 0, 0, 1);
+
Register r0(0);
builder.LoadLiteral(Smi::FromInt(inputs[i]))
.StoreAccumulatorInRegister(r0)
@@ -1203,6 +1227,7 @@
i::Factory* factory = handles.main_isolate()->factory();
BytecodeArrayBuilder builder(handles.main_isolate(),
handles.main_zone(), 0, 0, 1);
+
Register r0(0);
builder.LoadLiteral(factory->NewHeapNumber(inputs[i]))
.StoreAccumulatorInRegister(r0)
@@ -1236,6 +1261,7 @@
i::Factory* factory = handles.main_isolate()->factory();
BytecodeArrayBuilder builder(handles.main_isolate(),
handles.main_zone(), 0, 0, 1);
+
Register r0(0);
builder.LoadLiteral(factory->NewStringFromAsciiChecked(lhs))
.StoreAccumulatorInRegister(r0)
@@ -1280,6 +1306,7 @@
i::Factory* factory = handles.main_isolate()->factory();
BytecodeArrayBuilder builder(handles.main_isolate(),
handles.main_zone(), 0, 0, 1);
+
Register r0(0);
if (pass == 0) {
// Comparison with HeapNumber on the lhs and String on the rhs
@@ -1393,6 +1420,7 @@
bool expected_value = (i == 0);
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 0,
0, 1);
+
Register r0(0);
builder.LoadLiteral(cases[i]);
builder.StoreAccumulatorInRegister(r0)
@@ -1422,6 +1450,7 @@
bool expected_value = (i == 0);
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 0,
0, 1);
+
Register r0(0);
builder.LoadLiteral(factory->NewStringFromAsciiChecked(properties[i]))
.StoreAccumulatorInRegister(r0)
@@ -1445,6 +1474,7 @@
bool expected_value = ((i & 1) == 1);
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 0,
0, 0);
+
Register r0(0);
builder.LoadFalse();
for (size_t j = 0; j < i; j++) {
@@ -1506,6 +1536,7 @@
for (size_t i = 0; i < arraysize(object_type_tuples); i++) {
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 0,
0, 0);
+
Register r0(0);
LoadAny(&builder, factory, object_type_tuples[i].first);
builder.LogicalNot();
@@ -1552,6 +1583,7 @@
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 2);
+
builder.LoadLiteral(Smi::FromInt(15))
.StoreAccumulatorInRegister(Register(0))
.LoadLiteral(Smi::FromInt(40))
@@ -1572,6 +1604,7 @@
BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
0, 2);
+
builder.LoadLiteral(Smi::FromInt(15))
.StoreAccumulatorInRegister(Register(0))
.CallRuntime(Runtime::kInlineIsArray, Register(0), 1)
@@ -4154,8 +4187,7 @@
};
for (size_t i = 0; i < arraysize(tests); i++) {
- std::string source(
- InterpreterTester::SourceForBody(tests[i].first));
+ std::string source(InterpreterTester::SourceForBody(tests[i].first));
InterpreterTester tester(handles.main_isolate(), source.c_str());
auto callable = tester.GetCallable<>();
@@ -4166,7 +4198,6 @@
FLAG_ignition_generators = old_flag;
}
-
} // namespace interpreter
} // namespace internal
} // namespace v8
diff --git a/test/cctest/interpreter/test-source-positions.cc b/test/cctest/interpreter/test-source-positions.cc
new file mode 100644
index 0000000..19be47f
--- /dev/null
+++ b/test/cctest/interpreter/test-source-positions.cc
@@ -0,0 +1,252 @@
+// 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 "src/v8.h"
+
+#include "src/compiler/pipeline.h"
+#include "src/handles.h"
+#include "src/interpreter/bytecode-generator.h"
+#include "src/interpreter/interpreter.h"
+#include "src/isolate.h"
+#include "src/parsing/parser.h"
+#include "test/cctest/cctest.h"
+#include "test/cctest/interpreter/source-position-matcher.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+// Flags enabling optimizations that change generated bytecode array.
+// Format is <command-line flag> <flag name> <bit index>
+#define OPTIMIZATION_FLAGS(V) \
+ V(FLAG_ignition_reo, kUseReo, 0) \
+ V(FLAG_ignition_peephole, kUsePeephole, 1) \
+ V(FLAG_ignition_filter_expression_positions, kUseFilterExpressionPositions, \
+ 2) \
+ V(FLAG_ignition_deadcode, kUseDeadCode, 3)
+
+#define DECLARE_BIT(_, Name, BitIndex) static const int Name = 1 << BitIndex;
+OPTIMIZATION_FLAGS(DECLARE_BIT)
+#undef DECLARE_BIT
+
+// Test cases source positions are checked for. Please ensure all
+// combinations of flags are present here. This is done manually
+// because it provides easier to comprehend failure case for humans.
+#define TEST_CASES(V) \
+ V(UsingReo, kUseReo) \
+ V(UsingPeephole, kUsePeephole) \
+ V(UsingDeadCode, kUseDeadCode) \
+ V(UsingFilterExpressionPositions, kUseFilterExpressionPositions) \
+ V(UsingReoAndPeephole, kUseReo | kUsePeephole) \
+ V(UsingReoAndFilterExpressionPositions, \
+ kUseReo | kUseFilterExpressionPositions) \
+ V(UsingReoAndDeadCode, kUseReo | kUseDeadCode) \
+ V(UsingPeepholeAndFilterExpressionPositions, \
+ kUsePeephole | kUseFilterExpressionPositions) \
+ V(UsingPeepholeAndDeadCode, kUsePeephole | kUseDeadCode) \
+ V(UsingFilterExpressionPositionsAndDeadCode, \
+ kUseFilterExpressionPositions | kUseDeadCode) \
+ V(UsingAllOptimizations, \
+ kUseReo | kUsePeephole | kUseFilterExpressionPositions | kUseDeadCode)
+
+struct TestCaseData {
+ TestCaseData(const char* const script,
+ const char* const declaration_parameters = "",
+ const char* const arguments = "")
+ : script_(script),
+ declaration_parameters_(declaration_parameters),
+ arguments_(arguments) {}
+
+ const char* const script() const { return script_; }
+ const char* const declaration_parameters() const {
+ return declaration_parameters_;
+ }
+ const char* const arguments() const { return arguments_; }
+
+ private:
+ TestCaseData();
+
+ const char* const script_;
+ const char* const declaration_parameters_;
+ const char* const arguments_;
+};
+
+static const TestCaseData kTestCaseData[] = {
+ {"var x = (y = 3) + (x = y); return x + y;"},
+ {"var x = 55;\n"
+ "var y = x + (x = 1) + (x = 2) + (x = 3);\n"
+ "return y;"},
+ {"var x = 10; return x >>> 3;\n"},
+ {"var x = 0; return x || (1, 2, 3);\n"},
+ {"return a || (a, b, a, b, c = 5, 3);\n"},
+ {"var a = 3; var b = 4; a = b; b = a; a = b; return a;\n"},
+ {"var a = 1; return [[a, 2], [a + 2]];\n"},
+ {"var a = 1; if (a || a < 0) { return 1; }\n"},
+ {"var b;"
+ "b = a.name;"
+ "b = a.name;"
+ "a.name = a;"
+ "b = a.name;"
+ "a.name = a;"
+ "return b;"},
+ {"var sum = 0;\n"
+ "outer: {\n"
+ " for (var x = 0; x < 10; ++x) {\n"
+ " for (var y = 0; y < 3; ++y) {\n"
+ " ++sum;\n"
+ " if (x + y == 12) { break outer; }\n"
+ " }\n"
+ " }\n"
+ "}\n"
+ "return sum;\n"},
+ {"var a = 1;"
+ "switch (a) {"
+ " case 1: return a * a + 1;"
+ " case 1: break;"
+ " case 2: return (a = 3) * a + (a = 4);"
+ " case 3:"
+ "}"
+ "return a;"},
+ {"for (var p of [0, 1, 2]) {}"},
+ {"var x = { 'a': 1, 'b': 2 };"
+ "for (x['a'] of [1,2,3]) { return x['a']; }"},
+ {"while (x == 4) {\n"
+ " var y = x + 1;\n"
+ " if (y == 2) break;\n"
+ " for (z['a'] of [0]) {\n"
+ " x += (x *= 3) + y;"
+ " }\n"
+ "}\n"},
+ {"function g(a, b) { return a.func(b + b, b); }\n"
+ "g(new (function Obj() { this.func = function() { return; }})(), 1)\n"},
+ {"return some_global[name];", "name", "'a'"}};
+
+class OptimizedBytecodeSourcePositionTester final {
+ public:
+ explicit OptimizedBytecodeSourcePositionTester(Isolate* isolate)
+ : isolate_(isolate) {
+ SaveOptimizationFlags();
+ saved_flag_ignition_ = FLAG_ignition;
+ FLAG_ignition = true;
+ saved_flag_always_opt_ = FLAG_always_opt;
+ FLAG_always_opt = false;
+ }
+
+ ~OptimizedBytecodeSourcePositionTester() {
+ RestoreOptimizationFlags();
+ FLAG_ignition = saved_flag_ignition_;
+ FLAG_always_opt = saved_flag_always_opt_;
+ }
+
+ bool SourcePositionsMatch(int optimization_bitmap, const char* function_body,
+ const char* function_decl_params,
+ const char* function_args);
+
+ private:
+ Handle<BytecodeArray> MakeBytecode(int optimization_bitmap,
+ const char* function_body,
+ const char* function_decl_params,
+ const char* function_args);
+ static std::string MakeScript(const char* function_body,
+ const char* function_decl_params,
+ const char* function_args);
+
+ void SetOptimizationFlags(int optimization_bitmap);
+ void SaveOptimizationFlags();
+ void RestoreOptimizationFlags();
+
+ Isolate* isolate() const { return isolate_; }
+
+ Isolate* isolate_;
+ int saved_optimization_bitmap_;
+ bool saved_flag_ignition_;
+ bool saved_flag_always_opt_;
+};
+
+// static
+std::string OptimizedBytecodeSourcePositionTester::MakeScript(
+ const char* function_body, const char* function_decl_params,
+ const char* function_args) {
+ std::ostringstream os;
+ os << "function test_function"
+ << "(" << function_decl_params << ") {";
+ os << function_body;
+ os << "}";
+ os << "test_function(" << function_args << ");";
+ return os.str();
+}
+
+Handle<BytecodeArray> OptimizedBytecodeSourcePositionTester::MakeBytecode(
+ int optimization_bitmap, const char* function_body,
+ const char* function_decl_params, const char* function_args) {
+ std::string script =
+ MakeScript(function_body, function_decl_params, function_args);
+ SetOptimizationFlags(optimization_bitmap);
+ CompileRun(script.c_str());
+
+ Local<Function> api_function = Local<Function>::Cast(
+ CcTest::global()
+ ->Get(CcTest::isolate()->GetCurrentContext(), v8_str("test_function"))
+ .ToLocalChecked());
+ Handle<JSFunction> function =
+ Handle<JSFunction>::cast(v8::Utils::OpenHandle(*api_function));
+ return handle(function->shared()->bytecode_array());
+}
+
+void OptimizedBytecodeSourcePositionTester::SetOptimizationFlags(
+ int optimization_bitmap) {
+#define SET_FLAG(V8Flag, BitName, _) \
+ V8Flag = (optimization_bitmap & BitName) ? true : false;
+ OPTIMIZATION_FLAGS(SET_FLAG)
+#undef SET_FLAG
+}
+
+void OptimizedBytecodeSourcePositionTester::SaveOptimizationFlags() {
+ saved_optimization_bitmap_ = 0;
+#define SAVE_FLAG(V8Flag, BitName, _) \
+ if (V8Flag) saved_optimization_bitmap_ |= BitName;
+#undef SET_FLAG
+}
+
+void OptimizedBytecodeSourcePositionTester::RestoreOptimizationFlags() {
+ SetOptimizationFlags(saved_optimization_bitmap_);
+}
+
+bool OptimizedBytecodeSourcePositionTester::SourcePositionsMatch(
+ int optimization_bitmap, const char* function_body,
+ const char* function_decl_params, const char* function_args) {
+ Handle<BytecodeArray> unoptimized_bytecode =
+ MakeBytecode(0, function_body, function_decl_params, function_args);
+ Handle<BytecodeArray> optimized_bytecode = MakeBytecode(
+ optimization_bitmap, function_body, function_decl_params, function_args);
+ SourcePositionMatcher matcher;
+ if (!matcher.Match(unoptimized_bytecode, optimized_bytecode)) {
+ return false;
+ }
+ return true;
+}
+
+void TestSourcePositionsEquivalent(int optimization_bitmap) {
+ HandleAndZoneScope handles;
+ // Ensure handler table is generated.
+ handles.main_isolate()->interpreter()->Initialize();
+
+ OptimizedBytecodeSourcePositionTester tester(handles.main_isolate());
+ for (auto test_case_data : kTestCaseData) {
+ CHECK(tester.SourcePositionsMatch(
+ optimization_bitmap, test_case_data.script(),
+ test_case_data.declaration_parameters(), test_case_data.arguments()));
+ }
+}
+
+#define MAKE_TEST(Name, Bitmap) \
+ TEST(TestSourcePositionsEquivalent##Name) { \
+ TestSourcePositionsEquivalent(Bitmap); \
+ }
+TEST_CASES(MAKE_TEST)
+#undef MAKE_TEST
+
+} // namespace interpreter
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/libsampler/test-sampler.cc b/test/cctest/libsampler/test-sampler.cc
new file mode 100644
index 0000000..745b139
--- /dev/null
+++ b/test/cctest/libsampler/test-sampler.cc
@@ -0,0 +1,141 @@
+// 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.
+// Tests of sampler functionalities.
+
+#include "src/libsampler/v8-sampler.h"
+
+#include "src/base/platform/platform.h"
+#include "test/cctest/cctest.h"
+
+
+namespace v8 {
+namespace sampler {
+
+namespace {
+
+class TestSamplingThread : public base::Thread {
+ public:
+ static const int kSamplerThreadStackSize = 64 * 1024;
+
+ explicit TestSamplingThread(Sampler* sampler)
+ : Thread(base::Thread::Options("TestSamplingThread",
+ kSamplerThreadStackSize)),
+ sampler_(sampler) {}
+
+ // Implement Thread::Run().
+ void Run() override {
+ while (sampler_->IsProfiling()) {
+ sampler_->DoSample();
+ base::OS::Sleep(base::TimeDelta::FromMilliseconds(1));
+ }
+ }
+
+ private:
+ Sampler* sampler_;
+};
+
+
+class TestSampler : public Sampler {
+ public:
+ explicit TestSampler(Isolate* isolate) : Sampler(isolate) {}
+
+ void SampleStack(const v8::RegisterState& regs) override {
+ void* frames[Sampler::kMaxFramesCount];
+ SampleInfo sample_info;
+ isolate()->GetStackSample(regs, reinterpret_cast<void**>(frames),
+ Sampler::kMaxFramesCount, &sample_info);
+ if (is_counting_samples_) {
+ if (sample_info.vm_state == JS) ++js_sample_count_;
+ if (sample_info.vm_state == EXTERNAL) ++external_sample_count_;
+ }
+ }
+};
+
+
+class TestApiCallbacks {
+ public:
+ TestApiCallbacks() {}
+
+ static void Getter(v8::Local<v8::String> name,
+ const v8::PropertyCallbackInfo<v8::Value>& info) {
+ }
+
+ static void Setter(v8::Local<v8::String> name,
+ v8::Local<v8::Value> value,
+ const v8::PropertyCallbackInfo<void>& info) {
+ }
+};
+
+
+static void RunSampler(v8::Local<v8::Context> env,
+ v8::Local<v8::Function> function,
+ v8::Local<v8::Value> argv[], int argc,
+ unsigned min_js_samples = 0,
+ unsigned min_external_samples = 0) {
+ Sampler::SetUp();
+ TestSampler* sampler = new TestSampler(env->GetIsolate());
+ TestSamplingThread* thread = new TestSamplingThread(sampler);
+ sampler->IncreaseProfilingDepth();
+ sampler->Start();
+ sampler->StartCountingSamples();
+ thread->StartSynchronously();
+ do {
+ function->Call(env, env->Global(), argc, argv).ToLocalChecked();
+ } while (sampler->js_sample_count() < min_js_samples ||
+ sampler->external_sample_count() < min_external_samples);
+ sampler->Stop();
+ sampler->DecreaseProfilingDepth();
+ thread->Join();
+ delete thread;
+ delete sampler;
+ Sampler::TearDown();
+}
+
+} // namespace
+
+static const char* sampler_test_source = "function start(count) {\n"
+" for (var i = 0; i < count; i++) {\n"
+" var o = instance.foo;\n"
+" instance.foo = o + 1;\n"
+" }\n"
+"}\n";
+
+static v8::Local<v8::Function> GetFunction(v8::Local<v8::Context> env,
+ const char* name) {
+ return v8::Local<v8::Function>::Cast(
+ env->Global()->Get(env, v8_str(name)).ToLocalChecked());
+}
+
+
+TEST(LibSamplerCollectSample) {
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope scope(isolate);
+
+ v8::Local<v8::FunctionTemplate> func_template =
+ v8::FunctionTemplate::New(isolate);
+ v8::Local<v8::ObjectTemplate> instance_template =
+ func_template->InstanceTemplate();
+
+ TestApiCallbacks accessors;
+ v8::Local<v8::External> data =
+ v8::External::New(isolate, &accessors);
+ instance_template->SetAccessor(v8_str("foo"), &TestApiCallbacks::Getter,
+ &TestApiCallbacks::Setter, data);
+ v8::Local<v8::Function> func =
+ func_template->GetFunction(env.local()).ToLocalChecked();
+ v8::Local<v8::Object> instance =
+ func->NewInstance(env.local()).ToLocalChecked();
+ env->Global()->Set(env.local(), v8_str("instance"), instance).FromJust();
+
+ CompileRun(sampler_test_source);
+ v8::Local<v8::Function> function = GetFunction(env.local(), "start");
+
+ int32_t repeat_count = 100;
+ v8::Local<v8::Value> args[] = {v8::Integer::New(isolate, repeat_count)};
+ RunSampler(env.local(), function, args, arraysize(args), 100, 100);
+}
+
+} // namespace sampler
+} // namespace v8
diff --git a/test/cctest/test-access-checks.cc b/test/cctest/test-access-checks.cc
new file mode 100644
index 0000000..34b64c4
--- /dev/null
+++ b/test/cctest/test-access-checks.cc
@@ -0,0 +1,182 @@
+// 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 <stdlib.h>
+
+#include "test/cctest/cctest.h"
+
+namespace {
+
+int32_t g_cross_context_int = 0;
+
+void NamedGetter(v8::Local<v8::Name> property,
+ const v8::PropertyCallbackInfo<v8::Value>& info) {
+ v8::Isolate* isolate = info.GetIsolate();
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ if (property->Equals(context, v8_str("cross_context_int")).FromJust())
+ info.GetReturnValue().Set(g_cross_context_int);
+}
+
+void NamedSetter(v8::Local<v8::Name> property, v8::Local<v8::Value> value,
+ const v8::PropertyCallbackInfo<v8::Value>& info) {
+ v8::Isolate* isolate = info.GetIsolate();
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ if (!property->Equals(context, v8_str("cross_context_int")).FromJust())
+ return;
+ if (value->IsInt32()) {
+ g_cross_context_int = value->ToInt32(context).ToLocalChecked()->Value();
+ }
+ info.GetReturnValue().Set(value);
+}
+
+void NamedQuery(v8::Local<v8::Name> property,
+ const v8::PropertyCallbackInfo<v8::Integer>& info) {
+ v8::Isolate* isolate = info.GetIsolate();
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ if (!property->Equals(context, v8_str("cross_context_int")).FromJust())
+ return;
+ info.GetReturnValue().Set(v8::DontDelete);
+}
+
+void NamedDeleter(v8::Local<v8::Name> property,
+ const v8::PropertyCallbackInfo<v8::Boolean>& info) {
+ v8::Isolate* isolate = info.GetIsolate();
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ if (!property->Equals(context, v8_str("cross_context_int")).FromJust())
+ return;
+ info.GetReturnValue().Set(false);
+}
+
+void NamedEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info) {
+ v8::Isolate* isolate = info.GetIsolate();
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ v8::Local<v8::Array> names = v8::Array::New(isolate, 1);
+ names->Set(context, 0, v8_str("cross_context_int")).FromJust();
+ info.GetReturnValue().Set(names);
+}
+
+void IndexedGetter(uint32_t index,
+ const v8::PropertyCallbackInfo<v8::Value>& info) {
+ if (index == 7) info.GetReturnValue().Set(g_cross_context_int);
+}
+
+void IndexedSetter(uint32_t index, v8::Local<v8::Value> value,
+ const v8::PropertyCallbackInfo<v8::Value>& info) {
+ v8::Isolate* isolate = info.GetIsolate();
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ if (index != 7) return;
+ if (value->IsInt32()) {
+ g_cross_context_int = value->ToInt32(context).ToLocalChecked()->Value();
+ }
+ info.GetReturnValue().Set(value);
+}
+
+void IndexedQuery(uint32_t index,
+ const v8::PropertyCallbackInfo<v8::Integer>& info) {
+ if (index == 7) info.GetReturnValue().Set(v8::DontDelete);
+}
+
+void IndexedDeleter(uint32_t index,
+ const v8::PropertyCallbackInfo<v8::Boolean>& info) {
+ if (index == 7) info.GetReturnValue().Set(false);
+}
+
+void IndexedEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info) {
+ v8::Isolate* isolate = info.GetIsolate();
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ v8::Local<v8::Array> names = v8::Array::New(isolate, 1);
+ names->Set(context, 0, v8_str("7")).FromJust();
+ info.GetReturnValue().Set(names);
+}
+
+bool AccessCheck(v8::Local<v8::Context> accessing_context,
+ v8::Local<v8::Object> accessed_object,
+ v8::Local<v8::Value> data) {
+ return false;
+}
+
+void GetCrossContextInt(v8::Local<v8::String> property,
+ const v8::PropertyCallbackInfo<v8::Value>& info) {
+ info.GetReturnValue().Set(g_cross_context_int);
+}
+
+void SetCrossContextInt(v8::Local<v8::String> property,
+ v8::Local<v8::Value> value,
+ const v8::PropertyCallbackInfo<void>& info) {
+ v8::Isolate* isolate = info.GetIsolate();
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ if (value->IsInt32()) {
+ g_cross_context_int = value->ToInt32(context).ToLocalChecked()->Value();
+ }
+}
+
+void Return42(v8::Local<v8::String> property,
+ const v8::PropertyCallbackInfo<v8::Value>& info) {
+ info.GetReturnValue().Set(42);
+}
+
+} // namespace
+
+TEST(AccessCheckWithInterceptor) {
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope scope(isolate);
+ v8::Local<v8::ObjectTemplate> global_template =
+ v8::ObjectTemplate::New(isolate);
+ global_template->SetAccessCheckCallbackAndHandler(
+ AccessCheck,
+ v8::NamedPropertyHandlerConfiguration(
+ NamedGetter, NamedSetter, NamedQuery, NamedDeleter, NamedEnumerator),
+ v8::IndexedPropertyHandlerConfiguration(IndexedGetter, IndexedSetter,
+ IndexedQuery, IndexedDeleter,
+ IndexedEnumerator));
+ global_template->SetNativeDataProperty(
+ v8_str("cross_context_int"), GetCrossContextInt, SetCrossContextInt);
+ global_template->SetNativeDataProperty(
+ v8_str("all_can_read"), Return42, nullptr, v8::Local<v8::Value>(),
+ v8::None, v8::Local<v8::AccessorSignature>(), v8::ALL_CAN_READ);
+
+ v8::Local<v8::Context> context0 =
+ v8::Context::New(isolate, nullptr, global_template);
+ context0->Enter();
+
+ // Running script in this context should work.
+ CompileRunChecked(isolate, "this.foo = 42; this[23] = true;");
+ ExpectInt32("this.all_can_read", 42);
+ CompileRunChecked(isolate, "this.cross_context_int = 23");
+ CHECK_EQ(g_cross_context_int, 23);
+ ExpectInt32("this.cross_context_int", 23);
+
+ // Create another context.
+ {
+ v8::HandleScope other_scope(isolate);
+ v8::Local<v8::Context> context1 =
+ v8::Context::New(isolate, nullptr, global_template);
+ context1->Global()
+ ->Set(context1, v8_str("other"), context0->Global())
+ .FromJust();
+ v8::Context::Scope context_scope(context1);
+
+ {
+ v8::TryCatch try_catch(isolate);
+ CHECK(CompileRun(context1, "this.other.foo").IsEmpty());
+ }
+ {
+ v8::TryCatch try_catch(isolate);
+ CHECK(CompileRun(context1, "this.other[23]").IsEmpty());
+ }
+
+ // AllCanRead properties are also inaccessible.
+ {
+ v8::TryCatch try_catch(isolate);
+ CHECK(CompileRun(context1, "this.other.all_can_read").IsEmpty());
+ }
+
+ // Intercepted properties are accessible, however.
+ ExpectInt32("this.other.cross_context_int", 23);
+ CompileRunChecked(isolate, "this.other.cross_context_int = 42");
+ ExpectInt32("this.other[7]", 42);
+ ExpectString("JSON.stringify(Object.getOwnPropertyNames(this.other))",
+ "[\"7\",\"cross_context_int\"]");
+ }
+}
diff --git a/test/cctest/test-api-interceptors.cc b/test/cctest/test-api-interceptors.cc
index a1894fa..1636e4b 100644
--- a/test/cctest/test-api-interceptors.cc
+++ b/test/cctest/test-api-interceptors.cc
@@ -854,6 +854,66 @@
CHECK_EQ(42 * 10, value->Int32Value(context.local()).FromJust());
}
+// Test load of a non-existing global when a global object has an interceptor.
+THREADED_TEST(InterceptorLoadGlobalICGlobalWithInterceptor) {
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope scope(isolate);
+ v8::Local<v8::ObjectTemplate> templ_global = v8::ObjectTemplate::New(isolate);
+ templ_global->SetHandler(v8::NamedPropertyHandlerConfiguration(
+ EmptyInterceptorGetter, EmptyInterceptorSetter));
+
+ LocalContext context(nullptr, templ_global);
+ i::Handle<i::JSReceiver> global_proxy =
+ v8::Utils::OpenHandle<Object, i::JSReceiver>(context->Global());
+ CHECK(global_proxy->IsJSGlobalProxy());
+ i::Handle<i::JSGlobalObject> global(
+ i::JSGlobalObject::cast(global_proxy->map()->prototype()));
+ CHECK(global->map()->has_named_interceptor());
+
+ v8::Local<Value> value = CompileRun(
+ "var f = function() { "
+ " try {"
+ " x1;"
+ " } catch(e) {"
+ " }"
+ " return typeof x1 === 'undefined';"
+ "};"
+ "for (var i = 0; i < 10; i++) {"
+ " f();"
+ "};"
+ "f();");
+ CHECK_EQ(true, value->BooleanValue(context.local()).FromJust());
+
+ value = CompileRun(
+ "var f = function() { "
+ " try {"
+ " x2;"
+ " return false;"
+ " } catch(e) {"
+ " return true;"
+ " }"
+ "};"
+ "for (var i = 0; i < 10; i++) {"
+ " f();"
+ "};"
+ "f();");
+ CHECK_EQ(true, value->BooleanValue(context.local()).FromJust());
+
+ value = CompileRun(
+ "var f = function() { "
+ " try {"
+ " typeof(x3);"
+ " return true;"
+ " } catch(e) {"
+ " return false;"
+ " }"
+ "};"
+ "for (var i = 0; i < 10; i++) {"
+ " f();"
+ "};"
+ "f();");
+ CHECK_EQ(true, value->BooleanValue(context.local()).FromJust());
+}
static void InterceptorLoadICGetter0(
Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
@@ -2270,33 +2330,34 @@
// This order is not mandated by the spec, so this test is just
// documenting our behavior.
CHECK_EQ(17u, result->Length());
- // Indexed properties + indexed interceptor properties in numerical order.
- CHECK(v8_str("0")
+ // Indexed properties.
+ CHECK(v8_str("5")
->Equals(context.local(),
result->Get(context.local(), v8::Integer::New(isolate, 0))
.ToLocalChecked())
.FromJust());
- CHECK(v8_str("1")
+ CHECK(v8_str("10")
->Equals(context.local(),
result->Get(context.local(), v8::Integer::New(isolate, 1))
.ToLocalChecked())
.FromJust());
- CHECK(v8_str("5")
+ CHECK(v8_str("140000")
->Equals(context.local(),
result->Get(context.local(), v8::Integer::New(isolate, 2))
.ToLocalChecked())
.FromJust());
- CHECK(v8_str("10")
+ CHECK(v8_str("4294967294")
->Equals(context.local(),
result->Get(context.local(), v8::Integer::New(isolate, 3))
.ToLocalChecked())
.FromJust());
- CHECK(v8_str("140000")
+ // Indexed Interceptor properties
+ CHECK(v8_str("0")
->Equals(context.local(),
result->Get(context.local(), v8::Integer::New(isolate, 4))
.ToLocalChecked())
.FromJust());
- CHECK(v8_str("4294967294")
+ CHECK(v8_str("1")
->Equals(context.local(),
result->Get(context.local(), v8::Integer::New(isolate, 5))
.ToLocalChecked())
@@ -3245,6 +3306,25 @@
CompileRun("Number.prototype.__proto__ = new Bug; var x = 0; x.foo();");
}
+THREADED_TEST(Regress625155) {
+ LocalContext context;
+ v8::HandleScope scope(context->GetIsolate());
+ Local<FunctionTemplate> templ = FunctionTemplate::New(context->GetIsolate());
+ AddInterceptor(templ, EmptyInterceptorGetter, EmptyInterceptorSetter);
+ context->Global()
+ ->Set(context.local(), v8_str("Bug"),
+ templ->GetFunction(context.local()).ToLocalChecked())
+ .FromJust();
+ CompileRun(
+ "Number.prototype.__proto__ = new Bug;"
+ "var x;"
+ "x = 0xdead;"
+ "x.boom = 0;"
+ "x = 's';"
+ "x.boom = 0;"
+ "x = 1.5;"
+ "x.boom = 0;");
+}
THREADED_TEST(Regress125988) {
v8::HandleScope scope(CcTest::isolate());
diff --git a/test/cctest/test-api.cc b/test/cctest/test-api.cc
index da72ecd..5624e3f 100644
--- a/test/cctest/test-api.cc
+++ b/test/cctest/test-api.cc
@@ -47,11 +47,12 @@
#include "src/futex-emulation.h"
#include "src/objects.h"
#include "src/parsing/parser.h"
+#include "src/profiler/cpu-profiler.h"
#include "src/unicode-inl.h"
#include "src/utils.h"
#include "src/vm-state.h"
#include "test/cctest/heap/heap-tester.h"
-#include "test/cctest/heap/utils-inl.h"
+#include "test/cctest/heap/heap-utils.h"
static const bool kLogThreading = false;
@@ -555,40 +556,19 @@
CcTest::heap()->CollectGarbage(i::NEW_SPACE);
uint16_t* two_byte_string = AsciiToTwoByteString("s1");
- Local<String> small_string =
+ Local<String> local_string =
String::NewFromTwoByte(env->GetIsolate(), two_byte_string,
v8::NewStringType::kNormal)
.ToLocalChecked();
i::DeleteArray(two_byte_string);
- // We should refuse to externalize small strings.
- CHECK(!small_string->CanMakeExternal());
+ // We should refuse to externalize new space strings.
+ CHECK(!local_string->CanMakeExternal());
// Trigger GCs so that the newly allocated string moves to old gen.
CcTest::heap()->CollectGarbage(i::NEW_SPACE); // in survivor space now
CcTest::heap()->CollectGarbage(i::NEW_SPACE); // in old gen now
// Old space strings should be accepted.
- CHECK(small_string->CanMakeExternal());
-
- two_byte_string = AsciiToTwoByteString("small string 2");
- small_string = String::NewFromTwoByte(env->GetIsolate(), two_byte_string,
- v8::NewStringType::kNormal)
- .ToLocalChecked();
- i::DeleteArray(two_byte_string);
-
- const int buf_size = 10 * 1024;
- char* buf = i::NewArray<char>(buf_size);
- memset(buf, 'a', buf_size);
- buf[buf_size - 1] = '\0';
-
- two_byte_string = AsciiToTwoByteString(buf);
- Local<String> large_string =
- String::NewFromTwoByte(env->GetIsolate(), two_byte_string,
- v8::NewStringType::kNormal)
- .ToLocalChecked();
- i::DeleteArray(buf);
- i::DeleteArray(two_byte_string);
- // Large strings should be immediately accepted.
- CHECK(large_string->CanMakeExternal());
+ CHECK(local_string->CanMakeExternal());
}
@@ -600,23 +580,14 @@
CcTest::heap()->CollectGarbage(i::NEW_SPACE);
CcTest::heap()->CollectGarbage(i::NEW_SPACE);
- Local<String> small_string = v8_str("s1");
- // We should refuse to externalize small strings.
- CHECK(!small_string->CanMakeExternal());
+ Local<String> local_string = v8_str("s1");
+ // We should refuse to externalize new space strings.
+ CHECK(!local_string->CanMakeExternal());
// Trigger GCs so that the newly allocated string moves to old gen.
CcTest::heap()->CollectGarbage(i::NEW_SPACE); // in survivor space now
CcTest::heap()->CollectGarbage(i::NEW_SPACE); // in old gen now
// Old space strings should be accepted.
- CHECK(small_string->CanMakeExternal());
-
- const int buf_size = 10 * 1024;
- char* buf = i::NewArray<char>(buf_size);
- memset(buf, 'a', buf_size);
- buf[buf_size - 1] = '\0';
- Local<String> large_string = v8_str(buf);
- i::DeleteArray(buf);
- // Large strings should be immediately accepted.
- CHECK(large_string->CanMakeExternal());
+ CHECK(local_string->CanMakeExternal());
}
@@ -634,7 +605,7 @@
"slice('abcdefghijklmnopqrstuvwxyz');"));
// Trigger GCs so that the newly allocated string moves to old gen.
- SimulateFullSpace(CcTest::heap()->old_space());
+ i::heap::SimulateFullSpace(CcTest::heap()->old_space());
CcTest::heap()->CollectGarbage(i::NEW_SPACE); // in survivor space now
CcTest::heap()->CollectGarbage(i::NEW_SPACE); // in old gen now
@@ -2827,16 +2798,15 @@
CHECK(env->Global()
->Set(env.local(), v8_str("global"), global_proxy)
.FromJust());
- i::Handle<i::Object> original_hash;
+ int32_t hash1;
if (set_in_js) {
CompileRun("var m = new Set(); m.add(global);");
- original_hash = i::Handle<i::Object>(i_global_proxy->GetHash(), i_isolate);
+ i::Object* original_hash = i_global_proxy->GetHash();
+ CHECK(original_hash->IsSmi());
+ hash1 = i::Smi::cast(original_hash)->value();
} else {
- original_hash = i::Handle<i::Object>(
- i::Object::GetOrCreateHash(i_isolate, i_global_proxy));
+ hash1 = i::Object::GetOrCreateHash(i_isolate, i_global_proxy)->value();
}
- CHECK(original_hash->IsSmi());
- int32_t hash1 = i::Handle<i::Smi>::cast(original_hash)->value();
// Hash should be retained after being detached.
env->DetachGlobal();
int hash2 = global_proxy->GetIdentityHash();
@@ -13381,7 +13351,7 @@
value =
context->Global()->ObjectProtoToString(context.local()).ToLocalChecked();
CHECK(value->IsString() &&
- value->Equals(context.local(), v8_str("[object global]")).FromJust());
+ value->Equals(context.local(), v8_str("[object Object]")).FromJust());
// Check ordinary object
Local<Value> object =
@@ -13427,7 +13397,7 @@
value =
context->Global()->ObjectProtoToString(context.local()).ToLocalChecked();
CHECK(value->IsString() &&
- value->Equals(context.local(), v8_str("[object global]")).FromJust());
+ value->Equals(context.local(), v8_str("[object Object]")).FromJust());
// Check ordinary object
Local<Value> object = CompileRun("new Object()");
@@ -14610,9 +14580,8 @@
test.RunTest();
}
-
-static i::HashMap* code_map = NULL;
-static i::HashMap* jitcode_line_info = NULL;
+static v8::base::HashMap* code_map = NULL;
+static v8::base::HashMap* jitcode_line_info = NULL;
static int saw_bar = 0;
static int move_events = 0;
@@ -14672,7 +14641,7 @@
CHECK(event->code_start != NULL);
CHECK_NE(0, static_cast<int>(event->code_len));
CHECK(event->name.str != NULL);
- i::HashMap::Entry* entry = code_map->LookupOrInsert(
+ v8::base::HashMap::Entry* entry = code_map->LookupOrInsert(
event->code_start, i::ComputePointerHash(event->code_start));
entry->value = reinterpret_cast<void*>(event->code_len);
@@ -14691,7 +14660,8 @@
// Compiler::RecordFunctionCompilation) and the line endings
// calculations can cause a GC, which can move the newly created code
// before its existence can be logged.
- i::HashMap::Entry* entry = code_map->Lookup(event->code_start, hash);
+ v8::base::HashMap::Entry* entry =
+ code_map->Lookup(event->code_start, hash);
if (entry != NULL) {
++move_events;
@@ -14718,7 +14688,7 @@
DummyJitCodeLineInfo* line_info = new DummyJitCodeLineInfo();
v8::JitCodeEvent* temp_event = const_cast<v8::JitCodeEvent*>(event);
temp_event->user_data = line_info;
- i::HashMap::Entry* entry = jitcode_line_info->LookupOrInsert(
+ v8::base::HashMap::Entry* entry = jitcode_line_info->LookupOrInsert(
line_info, i::ComputePointerHash(line_info));
entry->value = reinterpret_cast<void*>(line_info);
}
@@ -14729,7 +14699,7 @@
case v8::JitCodeEvent::CODE_END_LINE_INFO_RECORDING: {
CHECK(event->user_data != NULL);
uint32_t hash = i::ComputePointerHash(event->user_data);
- i::HashMap::Entry* entry =
+ v8::base::HashMap::Entry* entry =
jitcode_line_info->Lookup(event->user_data, hash);
CHECK(entry != NULL);
delete reinterpret_cast<DummyJitCodeLineInfo*>(event->user_data);
@@ -14739,7 +14709,7 @@
case v8::JitCodeEvent::CODE_ADD_LINE_POS_INFO: {
CHECK(event->user_data != NULL);
uint32_t hash = i::ComputePointerHash(event->user_data);
- i::HashMap::Entry* entry =
+ v8::base::HashMap::Entry* entry =
jitcode_line_info->Lookup(event->user_data, hash);
CHECK(entry != NULL);
}
@@ -14781,10 +14751,10 @@
{
v8::HandleScope scope(isolate);
- i::HashMap code(MatchPointers);
+ v8::base::HashMap code(MatchPointers);
code_map = &code;
- i::HashMap lineinfo(MatchPointers);
+ v8::base::HashMap lineinfo(MatchPointers);
jitcode_line_info = &lineinfo;
saw_bar = 0;
@@ -14798,8 +14768,8 @@
for (int i = 0; i < kIterations; ++i) {
LocalContext env(isolate);
i::AlwaysAllocateScope always_allocate(i_isolate);
- SimulateFullSpace(i::FLAG_ignition ? heap->old_space()
- : heap->code_space());
+ i::heap::SimulateFullSpace(i::FLAG_ignition ? heap->old_space()
+ : heap->code_space());
CompileRun(script);
// Keep a strong reference to the code object in the handle scope.
@@ -14847,10 +14817,10 @@
CompileRun(script);
// Now get code through initial iteration.
- i::HashMap code(MatchPointers);
+ v8::base::HashMap code(MatchPointers);
code_map = &code;
- i::HashMap lineinfo(MatchPointers);
+ v8::base::HashMap lineinfo(MatchPointers);
jitcode_line_info = &lineinfo;
isolate->SetJitCodeEventHandler(v8::kJitCodeEventEnumExisting,
@@ -14883,8 +14853,7 @@
isolate->AdjustAmountOfExternalAllocatedMemory(kSize));
CHECK_EQ(baseline,
isolate->AdjustAmountOfExternalAllocatedMemory(-kSize));
- const int64_t kTriggerGCSize =
- v8::internal::Internals::kExternalAllocationLimit + 1;
+ const int64_t kTriggerGCSize = i::kExternalAllocationLimit + 1;
CHECK_EQ(baseline + kTriggerGCSize,
isolate->AdjustAmountOfExternalAllocatedMemory(kTriggerGCSize));
CHECK_EQ(baseline,
@@ -14896,8 +14865,7 @@
i::FLAG_incremental_marking = false;
CcTest::InitializeVM();
- const int64_t kTriggerGCSize =
- v8::internal::Internals::kExternalAllocationLimit + 1;
+ const int64_t kTriggerGCSize = i::kExternalAllocationLimit + 1;
v8::Isolate* isolate = CcTest::isolate();
isolate->AdjustAmountOfExternalAllocatedMemory(kTriggerGCSize);
}
@@ -15072,18 +15040,39 @@
CHECK_EQ(1224744689038.0, date.As<v8::Date>()->ValueOf());
}
+void CheckIsSymbolAt(v8::Isolate* isolate, v8::Local<v8::Array> properties,
+ unsigned index, const char* name) {
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ v8::Local<v8::Value> value =
+ properties->Get(context, v8::Integer::New(isolate, index))
+ .ToLocalChecked();
+ CHECK(value->IsSymbol());
+ v8::String::Utf8Value symbol_name(Local<Symbol>::Cast(value)->Name());
+ CHECK_EQ(0, strcmp(name, *symbol_name));
+}
+
+void CheckStringArray(v8::Isolate* isolate, v8::Local<v8::Array> properties,
+ unsigned length, const char* names[]) {
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ CHECK_EQ(length, properties->Length());
+ for (unsigned i = 0; i < length; i++) {
+ v8::Local<v8::Value> value =
+ properties->Get(context, v8::Integer::New(isolate, i)).ToLocalChecked();
+ if (names[i] == nullptr) {
+ DCHECK(value->IsSymbol());
+ } else {
+ v8::String::Utf8Value elm(value);
+ CHECK_EQ(0, strcmp(names[i], *elm));
+ }
+ }
+}
void CheckProperties(v8::Isolate* isolate, v8::Local<v8::Value> val,
- unsigned elmc, const char* elmv[]) {
+ unsigned length, const char* names[]) {
v8::Local<v8::Context> context = isolate->GetCurrentContext();
v8::Local<v8::Object> obj = val.As<v8::Object>();
v8::Local<v8::Array> props = obj->GetPropertyNames(context).ToLocalChecked();
- CHECK_EQ(elmc, props->Length());
- for (unsigned i = 0; i < elmc; i++) {
- v8::String::Utf8Value elm(
- props->Get(context, v8::Integer::New(isolate, i)).ToLocalChecked());
- CHECK_EQ(0, strcmp(elmv[i], *elm));
- }
+ CheckStringArray(isolate, props, length, names);
}
@@ -15194,6 +15183,97 @@
}
}
+THREADED_TEST(PropertyNames) {
+ LocalContext context;
+ v8::Isolate* isolate = context->GetIsolate();
+ v8::HandleScope scope(isolate);
+ v8::Local<v8::Value> result = CompileRun(
+ "var result = {0: 0, 1: 1, a: 2, b: 3};"
+ "result[Symbol('symbol')] = true;"
+ "result.__proto__ = {2: 4, 3: 5, c: 6, d: 7};"
+ "result;");
+ v8::Local<v8::Object> object = result.As<v8::Object>();
+ v8::PropertyFilter default_filter =
+ static_cast<v8::PropertyFilter>(v8::ONLY_ENUMERABLE | v8::SKIP_SYMBOLS);
+ v8::PropertyFilter include_symbols_filter = v8::ONLY_ENUMERABLE;
+
+ v8::Local<v8::Array> properties =
+ object->GetPropertyNames(context.local()).ToLocalChecked();
+ const char* expected_properties1[] = {"0", "1", "a", "b", "2", "3", "c", "d"};
+ CheckStringArray(isolate, properties, 8, expected_properties1);
+
+ properties =
+ object
+ ->GetPropertyNames(context.local(),
+ v8::KeyCollectionMode::kIncludePrototypes,
+ default_filter, v8::IndexFilter::kIncludeIndices)
+ .ToLocalChecked();
+ CheckStringArray(isolate, properties, 8, expected_properties1);
+
+ properties = object
+ ->GetPropertyNames(context.local(),
+ v8::KeyCollectionMode::kIncludePrototypes,
+ include_symbols_filter,
+ v8::IndexFilter::kIncludeIndices)
+ .ToLocalChecked();
+ const char* expected_properties1_1[] = {"0", "1", "a", "b", nullptr,
+ "2", "3", "c", "d"};
+ CheckStringArray(isolate, properties, 9, expected_properties1_1);
+ CheckIsSymbolAt(isolate, properties, 4, "symbol");
+
+ properties =
+ object
+ ->GetPropertyNames(context.local(),
+ v8::KeyCollectionMode::kIncludePrototypes,
+ default_filter, v8::IndexFilter::kSkipIndices)
+ .ToLocalChecked();
+ const char* expected_properties2[] = {"a", "b", "c", "d"};
+ CheckStringArray(isolate, properties, 4, expected_properties2);
+
+ properties = object
+ ->GetPropertyNames(context.local(),
+ v8::KeyCollectionMode::kIncludePrototypes,
+ include_symbols_filter,
+ v8::IndexFilter::kSkipIndices)
+ .ToLocalChecked();
+ const char* expected_properties2_1[] = {"a", "b", nullptr, "c", "d"};
+ CheckStringArray(isolate, properties, 5, expected_properties2_1);
+ CheckIsSymbolAt(isolate, properties, 2, "symbol");
+
+ properties =
+ object
+ ->GetPropertyNames(context.local(), v8::KeyCollectionMode::kOwnOnly,
+ default_filter, v8::IndexFilter::kIncludeIndices)
+ .ToLocalChecked();
+ const char* expected_properties3[] = {"0", "1", "a", "b"};
+ CheckStringArray(isolate, properties, 4, expected_properties3);
+
+ properties = object
+ ->GetPropertyNames(
+ context.local(), v8::KeyCollectionMode::kOwnOnly,
+ include_symbols_filter, v8::IndexFilter::kIncludeIndices)
+ .ToLocalChecked();
+ const char* expected_properties3_1[] = {"0", "1", "a", "b", nullptr};
+ CheckStringArray(isolate, properties, 5, expected_properties3_1);
+ CheckIsSymbolAt(isolate, properties, 4, "symbol");
+
+ properties =
+ object
+ ->GetPropertyNames(context.local(), v8::KeyCollectionMode::kOwnOnly,
+ default_filter, v8::IndexFilter::kSkipIndices)
+ .ToLocalChecked();
+ const char* expected_properties4[] = {"a", "b"};
+ CheckStringArray(isolate, properties, 2, expected_properties4);
+
+ properties = object
+ ->GetPropertyNames(
+ context.local(), v8::KeyCollectionMode::kOwnOnly,
+ include_symbols_filter, v8::IndexFilter::kSkipIndices)
+ .ToLocalChecked();
+ const char* expected_properties4_1[] = {"a", "b", nullptr};
+ CheckStringArray(isolate, properties, 3, expected_properties4_1);
+ CheckIsSymbolAt(isolate, properties, 2, "symbol");
+}
THREADED_TEST(AccessChecksReenabledCorrectly) {
LocalContext context;
@@ -18462,7 +18542,6 @@
THREADED_TEST(FunctionGetDebugName) {
- i::FLAG_harmony_function_name = true;
LocalContext env;
v8::HandleScope scope(env->GetIsolate());
const char* code =
@@ -19001,7 +19080,7 @@
++prologue_call_count_alloc;
// Simulate full heap to see if we will reenter this callback
- SimulateFullSpace(CcTest::heap()->new_space());
+ i::heap::SimulateFullSpace(CcTest::heap()->new_space());
Local<Object> obj = Object::New(isolate);
CHECK(!obj.IsEmpty());
@@ -19021,7 +19100,7 @@
++epilogue_call_count_alloc;
// Simulate full heap to see if we will reenter this callback
- SimulateFullSpace(CcTest::heap()->new_space());
+ i::heap::SimulateFullSpace(CcTest::heap()->new_space());
Local<Object> obj = Object::New(isolate);
CHECK(!obj.IsEmpty());
@@ -19997,7 +20076,6 @@
TEST(RegExp) {
- i::FLAG_harmony_unicode_regexps = true;
LocalContext context;
v8::HandleScope scope(context->GetIsolate());
@@ -21375,14 +21453,17 @@
env->GetIsolate()->SetMicrotasksPolicy(v8::MicrotasksPolicy::kAuto);
}
-
#ifdef ENABLE_DISASSEMBLER
-static int probes_counter = 0;
-static int misses_counter = 0;
-static int updates_counter = 0;
+// FLAG_test_primary_stub_cache and FLAG_test_secondary_stub_cache are read
+// only when ENABLE_DISASSEMBLER is not defined.
+namespace {
-static int* LookupCounter(const char* name) {
+int probes_counter = 0;
+int misses_counter = 0;
+int updates_counter = 0;
+
+int* LookupCounter(const char* name) {
if (strcmp(name, "c:V8.MegamorphicStubCacheProbes") == 0) {
return &probes_counter;
} else if (strcmp(name, "c:V8.MegamorphicStubCacheMisses") == 0) {
@@ -21393,24 +21474,28 @@
return NULL;
}
+const char* kMegamorphicTestProgram =
+ "function CreateClass(name) {\n"
+ " var src = \n"
+ " ` function ${name}() {};` +\n"
+ " ` ${name}.prototype.foo = function() {};` +\n"
+ " ` ${name};\\n`;\n"
+ " return (0, eval)(src);\n"
+ "}\n"
+ "function fooify(obj) { obj.foo(); };\n"
+ "var objs = [];\n"
+ "for (var i = 0; i < 6; i++) {\n"
+ " var Class = CreateClass('Class' + i);\n"
+ " var obj = new Class();\n"
+ " objs.push(obj);\n"
+ "}\n"
+ "for (var i = 0; i < 10000; i++) {\n"
+ " for (var obj of objs) {\n"
+ " fooify(obj);\n"
+ " }\n"
+ "}\n";
-static const char* kMegamorphicTestProgram =
- "function ClassA() { };"
- "function ClassB() { };"
- "ClassA.prototype.foo = function() { };"
- "ClassB.prototype.foo = function() { };"
- "function fooify(obj) { obj.foo(); };"
- "var a = new ClassA();"
- "var b = new ClassB();"
- "for (var i = 0; i < 10000; i++) {"
- " fooify(a);"
- " fooify(b);"
- "}";
-#endif
-
-
-static void StubCacheHelper(bool primary) {
-#ifdef ENABLE_DISASSEMBLER
+void StubCacheHelper(bool primary) {
i::FLAG_native_code_counters = true;
if (primary) {
i::FLAG_test_primary_stub_cache = true;
@@ -21418,36 +21503,47 @@
i::FLAG_test_secondary_stub_cache = true;
}
i::FLAG_crankshaft = false;
- LocalContext env;
- env->GetIsolate()->SetCounterFunction(LookupCounter);
- v8::HandleScope scope(env->GetIsolate());
- int initial_probes = probes_counter;
- int initial_misses = misses_counter;
- int initial_updates = updates_counter;
- CompileRun(kMegamorphicTestProgram);
- int probes = probes_counter - initial_probes;
- int misses = misses_counter - initial_misses;
- int updates = updates_counter - initial_updates;
- CHECK_LT(updates, 10);
- CHECK_LT(misses, 10);
- // TODO(verwaest): Update this test to overflow the degree of polymorphism
- // before megamorphism. The number of probes will only work once we teach the
- // serializer to embed references to counters in the stubs, given that the
- // megamorphic_stub_cache_probes is updated in a snapshot-generated stub.
- CHECK_GE(probes, 0);
-#endif
+ i::FLAG_turbo = false;
+ v8::Isolate::CreateParams create_params;
+ create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+ create_params.counter_lookup_callback = LookupCounter;
+ v8::Isolate* isolate = v8::Isolate::New(create_params);
+ i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+
+ if (!i_isolate->snapshot_available()) {
+ // The test is valid only for no-snapshot mode.
+ v8::Isolate::Scope isolate_scope(isolate);
+ LocalContext env(isolate);
+ v8::HandleScope scope(isolate);
+
+ int initial_probes = probes_counter;
+ int initial_misses = misses_counter;
+ int initial_updates = updates_counter;
+ CompileRun(kMegamorphicTestProgram);
+ int probes = probes_counter - initial_probes;
+ int misses = misses_counter - initial_misses;
+ int updates = updates_counter - initial_updates;
+ const int kClassesCount = 6;
+ // Check that updates and misses counts are bounded.
+ CHECK_LE(kClassesCount, updates);
+ CHECK_LT(updates, kClassesCount * 3);
+ CHECK_LE(1, misses);
+ CHECK_LT(misses, kClassesCount * 2);
+ // 2 is for PREMONOMORPHIC and MONOMORPHIC states,
+ // 4 is for POLYMORPHIC states,
+ // and all the others probes are for MEGAMORPHIC state.
+ CHECK_EQ(10000 * kClassesCount - 2 - 4, probes);
+ }
+ isolate->Dispose();
}
+} // namespace
-TEST(SecondaryStubCache) {
- StubCacheHelper(true);
-}
+UNINITIALIZED_TEST(PrimaryStubCache) { StubCacheHelper(true); }
+UNINITIALIZED_TEST(SecondaryStubCache) { StubCacheHelper(false); }
-TEST(PrimaryStubCache) {
- StubCacheHelper(false);
-}
-
+#endif // ENABLE_DISASSEMBLER
#ifdef DEBUG
static int cow_arrays_created_runtime = 0;
@@ -22053,6 +22149,20 @@
ExpectString("JSON.stringify(obj)", *utf8);
}
+THREADED_TEST(JSONStringifyObjectWithGap) {
+ 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, v8_str("*")).ToLocalChecked();
+ v8::String::Utf8Value utf8(json);
+ ExpectString("JSON.stringify(obj, null, '*')", *utf8);
+}
+
#if V8_OS_POSIX && !V8_OS_NACL
class ThreadInterruptTest {
public:
@@ -23413,6 +23523,88 @@
CHECK_EQ(13, line_number);
}
+TEST(ScriptPositionInfo) {
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope scope(isolate);
+ const char* url = "http://www.foo.com/foo.js";
+ v8::ScriptOrigin origin(v8_str(url), v8::Integer::New(isolate, 13));
+ v8::ScriptCompiler::Source script_source(v8_str("var foo;\n"
+ "var bar;\n"
+ "var fisk = foo + bar;\n"),
+ origin);
+ Local<Script> script =
+ v8::ScriptCompiler::Compile(env.local(), &script_source).ToLocalChecked();
+
+ i::Handle<i::SharedFunctionInfo> obj = i::Handle<i::SharedFunctionInfo>::cast(
+ v8::Utils::OpenHandle(*script->GetUnboundScript()));
+ CHECK(obj->script()->IsScript());
+
+ i::Handle<i::Script> script1(i::Script::cast(obj->script()));
+
+ v8::internal::Script::PositionInfo info;
+
+ // With offset.
+
+ // Behave as if 0 was passed if position is negative.
+ CHECK(script1->GetPositionInfo(-1, &info, script1->WITH_OFFSET));
+ CHECK_EQ(13, info.line);
+ CHECK_EQ(0, info.column);
+ CHECK_EQ(0, info.line_start);
+ CHECK_EQ(8, info.line_end);
+
+ CHECK(script1->GetPositionInfo(0, &info, script1->WITH_OFFSET));
+ CHECK_EQ(13, info.line);
+ CHECK_EQ(0, info.column);
+ CHECK_EQ(0, info.line_start);
+ CHECK_EQ(8, info.line_end);
+
+ CHECK(script1->GetPositionInfo(8, &info, script1->WITH_OFFSET));
+ CHECK_EQ(13, info.line);
+ CHECK_EQ(8, info.column);
+ CHECK_EQ(0, info.line_start);
+ CHECK_EQ(8, info.line_end);
+
+ CHECK(script1->GetPositionInfo(9, &info, script1->WITH_OFFSET));
+ CHECK_EQ(14, info.line);
+ CHECK_EQ(0, info.column);
+ CHECK_EQ(9, info.line_start);
+ CHECK_EQ(17, info.line_end);
+
+ // Fail when position is larger than script size.
+ CHECK(!script1->GetPositionInfo(220384, &info, script1->WITH_OFFSET));
+
+ // Without offset.
+
+ // Behave as if 0 was passed if position is negative.
+ CHECK(script1->GetPositionInfo(-1, &info, script1->NO_OFFSET));
+ CHECK_EQ(0, info.line);
+ CHECK_EQ(0, info.column);
+ CHECK_EQ(0, info.line_start);
+ CHECK_EQ(8, info.line_end);
+
+ CHECK(script1->GetPositionInfo(0, &info, script1->NO_OFFSET));
+ CHECK_EQ(0, info.line);
+ CHECK_EQ(0, info.column);
+ CHECK_EQ(0, info.line_start);
+ CHECK_EQ(8, info.line_end);
+
+ CHECK(script1->GetPositionInfo(8, &info, script1->NO_OFFSET));
+ CHECK_EQ(0, info.line);
+ CHECK_EQ(8, info.column);
+ CHECK_EQ(0, info.line_start);
+ CHECK_EQ(8, info.line_end);
+
+ CHECK(script1->GetPositionInfo(9, &info, script1->NO_OFFSET));
+ CHECK_EQ(1, info.line);
+ CHECK_EQ(0, info.column);
+ CHECK_EQ(9, info.line_start);
+ CHECK_EQ(17, info.line_end);
+
+ // Fail when position is larger than script size.
+ CHECK(!script1->GetPositionInfo(220384, &info, script1->NO_OFFSET));
+}
+
void CheckMagicComments(Local<Script> script, const char* expected_source_url,
const char* expected_source_mapping_url) {
if (expected_source_url != NULL) {
diff --git a/test/cctest/test-api.h b/test/cctest/test-api.h
index 8887a8a..f9a335a 100644
--- a/test/cctest/test-api.h
+++ b/test/cctest/test-api.h
@@ -5,7 +5,6 @@
#include "src/v8.h"
#include "src/isolate.h"
-#include "src/profiler/cpu-profiler.h"
#include "src/vm-state.h"
#include "test/cctest/cctest.h"
@@ -14,10 +13,11 @@
v8::ReturnValue<v8::Value> rv = t.GetReturnValue();
i::Object** o = *reinterpret_cast<i::Object***>(&rv);
CHECK_EQ(CcTest::isolate(), t.GetIsolate());
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(t.GetIsolate());
CHECK_EQ(t.GetIsolate(), rv.GetIsolate());
- CHECK((*o)->IsTheHole() || (*o)->IsUndefined());
+ CHECK((*o)->IsTheHole(isolate) || (*o)->IsUndefined(isolate));
// Verify reset
- bool is_runtime = (*o)->IsTheHole();
+ bool is_runtime = (*o)->IsTheHole(isolate);
if (is_runtime) {
CHECK(rv.Get()->IsUndefined());
} else {
@@ -25,14 +25,13 @@
CHECK_EQ(*v, *o);
}
rv.Set(true);
- CHECK(!(*o)->IsTheHole() && !(*o)->IsUndefined());
+ CHECK(!(*o)->IsTheHole(isolate) && !(*o)->IsUndefined(isolate));
rv.Set(v8::Local<v8::Object>());
- CHECK((*o)->IsTheHole() || (*o)->IsUndefined());
- CHECK_EQ(is_runtime, (*o)->IsTheHole());
- i::Isolate* isolate = reinterpret_cast<i::Isolate*>(t.GetIsolate());
+ CHECK((*o)->IsTheHole(isolate) || (*o)->IsUndefined(isolate));
+ CHECK_EQ(is_runtime, (*o)->IsTheHole(isolate));
// If CPU profiler is active check that when API callback is invoked
// VMState is set to EXTERNAL.
- if (isolate->cpu_profiler()->is_profiling()) {
+ if (isolate->is_profiling()) {
CHECK_EQ(v8::EXTERNAL, isolate->current_vm_state());
CHECK(isolate->external_callback_scope());
CHECK_EQ(callback, isolate->external_callback_scope()->callback());
diff --git a/test/cctest/test-asm-validator.cc b/test/cctest/test-asm-validator.cc
index a07eecf..39d490e 100644
--- a/test/cctest/test-asm-validator.cc
+++ b/test/cctest/test-asm-validator.cc
@@ -1361,6 +1361,12 @@
"asm: line 1: left and right side of comparison must match\n");
}
+TEST(FunctionRepeated) {
+ CHECK_FUNC_ERROR(
+ "function foo() { return 0; }\n"
+ "function foo() { return 0; }",
+ "asm: line 2: function repeated in module\n");
+}
TEST(Float64ToInt32) {
CHECK_FUNC_TYPES_BEGIN(
diff --git a/test/cctest/test-assembler-s390.cc b/test/cctest/test-assembler-s390.cc
index dee8e07..ab6796b 100644
--- a/test/cctest/test-assembler-s390.cc
+++ b/test/cctest/test-assembler-s390.cc
@@ -202,7 +202,7 @@
__ sll(r13, Operand(10));
v8::internal::byte* bufPos = assm.buffer_pos();
- ::printf("buffer position = %p", bufPos);
+ ::printf("buffer position = %p", static_cast<void*>(bufPos));
::fflush(stdout);
// OS::DebugBreak();
diff --git a/test/cctest/test-assembler-x64.cc b/test/cctest/test-assembler-x64.cc
index e18ae71..00d3609 100644
--- a/test/cctest/test-assembler-x64.cc
+++ b/test/cctest/test-assembler-x64.cc
@@ -2296,4 +2296,24 @@
}
}
+TEST(AssemblerX64PslldWithXmm15) {
+ 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));
+
+ __ movq(xmm15, arg1);
+ __ pslld(xmm15, 1);
+ __ movq(rax, xmm15);
+ __ ret(0);
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ uint64_t result = FUNCTION_CAST<F5>(buffer)(V8_UINT64_C(0x1122334455667788));
+ CHECK_EQ(V8_UINT64_C(0x22446688aaccef10), result);
+}
+
#undef __
diff --git a/test/cctest/test-code-cache.cc b/test/cctest/test-code-cache.cc
new file mode 100644
index 0000000..817fa15
--- /dev/null
+++ b/test/cctest/test-code-cache.cc
@@ -0,0 +1,77 @@
+// 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/v8.h"
+
+#include "src/list.h"
+#include "src/objects.h"
+#include "test/cctest/cctest.h"
+
+namespace v8 {
+namespace internal {
+
+namespace {
+
+static Handle<Code> GetDummyCode(Isolate* isolate) {
+ CodeDesc desc = {nullptr, // buffer
+ 0, // buffer_size
+ 0, // instr_size
+ 0, // reloc_size
+ 0, // constant_pool_size
+ nullptr, // unwinding_info
+ 0, // unwinding_info_size
+ nullptr}; // origin
+ Code::Flags flags =
+ Code::ComputeFlags(Code::LOAD_IC, kNoExtraICState, kCacheOnReceiver);
+ Handle<Code> self_ref;
+ return isolate->factory()->NewCode(desc, flags, self_ref);
+}
+
+} // namespace
+
+TEST(CodeCache) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* factory = isolate->factory();
+ HandleScope handle_scope(isolate);
+
+ Handle<Map> map =
+ factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize, FAST_ELEMENTS);
+
+ // This number should be large enough to cause the code cache to use its
+ // hash table storage format.
+ static const int kEntries = 150;
+
+ // Prepare name/code pairs.
+ List<Handle<Name>> names(kEntries);
+ List<Handle<Code>> codes(kEntries);
+ for (int i = 0; i < kEntries; i++) {
+ names.Add(isolate->factory()->NewSymbol());
+ codes.Add(GetDummyCode(isolate));
+ }
+ Handle<Name> bad_name = isolate->factory()->NewSymbol();
+ Code::Flags bad_flags =
+ Code::ComputeFlags(Code::LOAD_IC, kNoExtraICState, kCacheOnPrototype);
+ DCHECK(bad_flags != codes[0]->flags());
+
+ // Cache name/code pairs.
+ for (int i = 0; i < kEntries; i++) {
+ Handle<Name> name = names.at(i);
+ Handle<Code> code = codes.at(i);
+ Map::UpdateCodeCache(map, name, code);
+ CHECK_EQ(*code, map->LookupInCodeCache(*name, code->flags()));
+ CHECK_NULL(map->LookupInCodeCache(*name, bad_flags));
+ }
+ CHECK_NULL(map->LookupInCodeCache(*bad_name, bad_flags));
+
+ // Check that lookup works not only right after storing.
+ for (int i = 0; i < kEntries; i++) {
+ Handle<Name> name = names.at(i);
+ Handle<Code> code = codes.at(i);
+ CHECK_EQ(*code, map->LookupInCodeCache(*name, code->flags()));
+ }
+}
+
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/test-code-layout.cc b/test/cctest/test-code-layout.cc
new file mode 100644
index 0000000..a88c878
--- /dev/null
+++ b/test/cctest/test-code-layout.cc
@@ -0,0 +1,84 @@
+// 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/objects.h"
+#include "test/cctest/cctest.h"
+
+using namespace v8::internal;
+
+TEST(CodeLayoutWithoutUnwindingInfo) {
+ CcTest::InitializeVM();
+ HandleScope handle_scope(CcTest::i_isolate());
+
+ // "Hello, World!" in ASCII.
+ byte buffer_array[13] = {0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20,
+ 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x21};
+
+ byte* buffer = &buffer_array[0];
+ int buffer_size = sizeof(buffer_array);
+
+ CodeDesc code_desc;
+ code_desc.buffer = buffer;
+ code_desc.buffer_size = buffer_size;
+ code_desc.constant_pool_size = 0;
+ code_desc.instr_size = buffer_size;
+ code_desc.reloc_size = 0;
+ code_desc.origin = nullptr;
+ code_desc.unwinding_info = nullptr;
+ code_desc.unwinding_info_size = 0;
+
+ Handle<Code> code = CcTest::i_isolate()->factory()->NewCode(
+ code_desc, 0, Handle<Object>::null());
+
+ CHECK(!code->has_unwinding_info());
+ CHECK_EQ(code->instruction_size(), buffer_size);
+ CHECK_EQ(memcmp(code->instruction_start(), buffer, buffer_size), 0);
+ CHECK_EQ(code->instruction_end() - reinterpret_cast<byte*>(*code),
+ Code::kHeaderSize + buffer_size - kHeapObjectTag);
+}
+
+TEST(CodeLayoutWithUnwindingInfo) {
+ CcTest::InitializeVM();
+ HandleScope handle_scope(CcTest::i_isolate());
+
+ // "Hello, World!" in ASCII.
+ byte buffer_array[13] = {0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20,
+ 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x21};
+
+ // "JavaScript" in ASCII.
+ byte unwinding_info_array[10] = {0x4a, 0x61, 0x76, 0x61, 0x53,
+ 0x63, 0x72, 0x69, 0x70, 0x74};
+
+ byte* buffer = &buffer_array[0];
+ int buffer_size = sizeof(buffer_array);
+ byte* unwinding_info = &unwinding_info_array[0];
+ int unwinding_info_size = sizeof(unwinding_info_array);
+
+ CodeDesc code_desc;
+ code_desc.buffer = buffer;
+ code_desc.buffer_size = buffer_size;
+ code_desc.constant_pool_size = 0;
+ code_desc.instr_size = buffer_size;
+ code_desc.reloc_size = 0;
+ code_desc.origin = nullptr;
+ code_desc.unwinding_info = unwinding_info;
+ code_desc.unwinding_info_size = unwinding_info_size;
+
+ Handle<Code> code = CcTest::i_isolate()->factory()->NewCode(
+ code_desc, 0, Handle<Object>::null());
+
+ CHECK(code->has_unwinding_info());
+ CHECK_EQ(code->instruction_size(), buffer_size);
+ CHECK_EQ(memcmp(code->instruction_start(), buffer, buffer_size), 0);
+ CHECK(IsAligned(code->GetUnwindingInfoSizeOffset(), 8));
+ CHECK_EQ(code->unwinding_info_size(), unwinding_info_size);
+ CHECK(
+ IsAligned(reinterpret_cast<uintptr_t>(code->unwinding_info_start()), 8));
+ CHECK_EQ(
+ memcmp(code->unwinding_info_start(), unwinding_info, unwinding_info_size),
+ 0);
+ CHECK_EQ(code->unwinding_info_end() - reinterpret_cast<byte*>(*code),
+ Code::kHeaderSize + RoundUp(buffer_size, kInt64Size) + kInt64Size +
+ unwinding_info_size - kHeapObjectTag);
+}
diff --git a/test/cctest/test-code-stub-assembler.cc b/test/cctest/test-code-stub-assembler.cc
new file mode 100644
index 0000000..2d9b666
--- /dev/null
+++ b/test/cctest/test-code-stub-assembler.cc
@@ -0,0 +1,1375 @@
+// 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 "src/base/utils/random-number-generator.h"
+#include "src/ic/stub-cache.h"
+#include "src/isolate.h"
+#include "test/cctest/compiler/code-assembler-tester.h"
+#include "test/cctest/compiler/function-tester.h"
+
+namespace v8 {
+namespace internal {
+
+using compiler::FunctionTester;
+using compiler::Node;
+
+typedef compiler::CodeAssemblerTesterImpl<CodeStubAssembler>
+ CodeStubAssemblerTester;
+
+TEST(FixedArrayAccessSmiIndex) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeStubAssemblerTester m(isolate, descriptor);
+ Handle<FixedArray> array = isolate->factory()->NewFixedArray(5);
+ array->set(4, Smi::FromInt(733));
+ 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();
+ CHECK_EQ(733, Handle<Smi>::cast(result.ToHandleChecked())->value());
+}
+
+TEST(LoadHeapNumberValue) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeStubAssemblerTester m(isolate, descriptor);
+ Handle<HeapNumber> number = isolate->factory()->NewHeapNumber(1234);
+ m.Return(m.SmiTag(
+ m.ChangeFloat64ToUint32(m.LoadHeapNumberValue(m.HeapConstant(number)))));
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(descriptor, code);
+ MaybeHandle<Object> result = ft.Call();
+ CHECK_EQ(1234, Handle<Smi>::cast(result.ToHandleChecked())->value());
+}
+
+TEST(LoadInstanceType) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeStubAssemblerTester m(isolate, descriptor);
+ Handle<HeapObject> undefined = isolate->factory()->undefined_value();
+ m.Return(m.SmiTag(m.LoadInstanceType(m.HeapConstant(undefined))));
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(descriptor, code);
+ MaybeHandle<Object> result = ft.Call();
+ CHECK_EQ(InstanceType::ODDBALL_TYPE,
+ Handle<Smi>::cast(result.ToHandleChecked())->value());
+}
+
+TEST(BitFieldDecode) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeStubAssemblerTester m(isolate, descriptor);
+
+ class TestBitField : public BitField<unsigned, 3, 3> {};
+ m.Return(m.SmiTag(m.BitFieldDecode<TestBitField>(m.Int32Constant(0x2f))));
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(descriptor, code);
+ MaybeHandle<Object> result = ft.Call();
+ // value = 00101111
+ // mask = 00111000
+ // result = 101
+ CHECK_EQ(5, Handle<Smi>::cast(result.ToHandleChecked())->value());
+}
+
+TEST(JSFunction) {
+ const int kNumParams = 3; // Receiver, left, right.
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ CodeStubAssemblerTester m(isolate, kNumParams);
+ m.Return(m.SmiFromWord32(m.Int32Add(m.SmiToWord32(m.Parameter(1)),
+ m.SmiToWord32(m.Parameter(2)))));
+
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ MaybeHandle<Object> result = ft.Call(isolate->factory()->undefined_value(),
+ handle(Smi::FromInt(23), isolate),
+ handle(Smi::FromInt(34), isolate));
+ CHECK_EQ(57, Handle<Smi>::cast(result.ToHandleChecked())->value());
+}
+
+TEST(ComputeIntegerHash) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ const int kNumParams = 2;
+ CodeStubAssemblerTester m(isolate, kNumParams);
+ m.Return(m.SmiFromWord32(m.ComputeIntegerHash(
+ m.SmiToWord32(m.Parameter(0)), m.SmiToWord32(m.Parameter(1)))));
+
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<Smi> hash_seed = isolate->factory()->hash_seed();
+
+ base::RandomNumberGenerator rand_gen(FLAG_random_seed);
+
+ for (int i = 0; i < 1024; i++) {
+ int k = rand_gen.NextInt(Smi::kMaxValue);
+
+ Handle<Smi> key(Smi::FromInt(k), isolate);
+ Handle<Object> result = ft.Call(key, hash_seed).ToHandleChecked();
+
+ uint32_t hash = ComputeIntegerHash(k, hash_seed->value());
+ Smi* expected = Smi::FromInt(hash & Smi::kMaxValue);
+ CHECK_EQ(expected, Smi::cast(*result));
+ }
+}
+
+TEST(TryToName) {
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+
+ const int kNumParams = 3;
+ CodeStubAssemblerTester m(isolate, kNumParams);
+
+ enum Result { kKeyIsIndex, kKeyIsUnique, kBailout };
+ {
+ Node* key = m.Parameter(0);
+ Node* expected_result = m.Parameter(1);
+ Node* expected_arg = m.Parameter(2);
+
+ Label passed(&m), failed(&m);
+ Label if_keyisindex(&m), if_keyisunique(&m), if_bailout(&m);
+ Variable var_index(&m, MachineRepresentation::kWord32);
+
+ m.TryToName(key, &if_keyisindex, &var_index, &if_keyisunique, &if_bailout);
+
+ m.Bind(&if_keyisindex);
+ m.GotoUnless(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kKeyIsIndex))),
+ &failed);
+ m.Branch(m.Word32Equal(m.SmiToWord32(expected_arg), var_index.value()),
+ &passed, &failed);
+
+ m.Bind(&if_keyisunique);
+ m.GotoUnless(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kKeyIsUnique))),
+ &failed);
+ m.Branch(m.WordEqual(expected_arg, key), &passed, &failed);
+
+ m.Bind(&if_bailout);
+ m.Branch(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kBailout))),
+ &passed, &failed);
+
+ m.Bind(&passed);
+ m.Return(m.BooleanConstant(true));
+
+ m.Bind(&failed);
+ m.Return(m.BooleanConstant(false));
+ }
+
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<Object> expect_index(Smi::FromInt(kKeyIsIndex), isolate);
+ Handle<Object> expect_unique(Smi::FromInt(kKeyIsUnique), isolate);
+ Handle<Object> expect_bailout(Smi::FromInt(kBailout), isolate);
+
+ {
+ // TryToName(<zero smi>) => if_keyisindex: smi value.
+ Handle<Object> key(Smi::FromInt(0), isolate);
+ ft.CheckTrue(key, expect_index, key);
+ }
+
+ {
+ // TryToName(<positive smi>) => if_keyisindex: smi value.
+ Handle<Object> key(Smi::FromInt(153), isolate);
+ ft.CheckTrue(key, expect_index, key);
+ }
+
+ {
+ // TryToName(<negative smi>) => bailout.
+ Handle<Object> key(Smi::FromInt(-1), isolate);
+ ft.CheckTrue(key, expect_bailout);
+ }
+
+ {
+ // TryToName(<symbol>) => if_keyisunique: <symbol>.
+ Handle<Object> key = isolate->factory()->NewSymbol();
+ ft.CheckTrue(key, expect_unique, key);
+ }
+
+ {
+ // TryToName(<internalized string>) => if_keyisunique: <internalized string>
+ Handle<Object> key = isolate->factory()->InternalizeUtf8String("test");
+ ft.CheckTrue(key, expect_unique, key);
+ }
+
+ {
+ // TryToName(<internalized number string>) => if_keyisindex: number.
+ Handle<Object> key = isolate->factory()->InternalizeUtf8String("153");
+ Handle<Object> index(Smi::FromInt(153), isolate);
+ ft.CheckTrue(key, expect_index, index);
+ }
+
+ {
+ // TryToName(<non-internalized string>) => bailout.
+ Handle<Object> key = isolate->factory()->NewStringFromAsciiChecked("test");
+ ft.CheckTrue(key, expect_bailout);
+ }
+}
+
+namespace {
+
+template <typename Dictionary>
+void TestNameDictionaryLookup() {
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+
+ const int kNumParams = 4;
+ CodeStubAssemblerTester m(isolate, kNumParams);
+
+ enum Result { kFound, kNotFound };
+ {
+ Node* dictionary = m.Parameter(0);
+ Node* unique_name = m.Parameter(1);
+ Node* expected_result = m.Parameter(2);
+ Node* expected_arg = m.Parameter(3);
+
+ Label passed(&m), failed(&m);
+ Label if_found(&m), if_not_found(&m);
+ Variable var_name_index(&m, MachineRepresentation::kWord32);
+
+ m.NameDictionaryLookup<Dictionary>(dictionary, unique_name, &if_found,
+ &var_name_index, &if_not_found);
+ m.Bind(&if_found);
+ m.GotoUnless(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kFound))),
+ &failed);
+ m.Branch(m.Word32Equal(m.SmiToWord32(expected_arg), var_name_index.value()),
+ &passed, &failed);
+
+ m.Bind(&if_not_found);
+ m.Branch(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kNotFound))),
+ &passed, &failed);
+
+ m.Bind(&passed);
+ m.Return(m.BooleanConstant(true));
+
+ m.Bind(&failed);
+ m.Return(m.BooleanConstant(false));
+ }
+
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<Object> expect_found(Smi::FromInt(kFound), isolate);
+ Handle<Object> expect_not_found(Smi::FromInt(kNotFound), isolate);
+
+ Handle<Dictionary> dictionary = Dictionary::New(isolate, 40);
+ PropertyDetails fake_details = PropertyDetails::Empty();
+
+ Factory* factory = isolate->factory();
+ Handle<Name> keys[] = {
+ factory->InternalizeUtf8String("0"),
+ factory->InternalizeUtf8String("42"),
+ factory->InternalizeUtf8String("-153"),
+ factory->InternalizeUtf8String("0.0"),
+ factory->InternalizeUtf8String("4.2"),
+ factory->InternalizeUtf8String(""),
+ factory->InternalizeUtf8String("name"),
+ factory->NewSymbol(),
+ factory->NewPrivateSymbol(),
+ };
+
+ for (size_t i = 0; i < arraysize(keys); i++) {
+ Handle<Object> value = factory->NewPropertyCell();
+ dictionary = Dictionary::Add(dictionary, keys[i], value, fake_details);
+ }
+
+ for (size_t i = 0; i < arraysize(keys); i++) {
+ int entry = dictionary->FindEntry(keys[i]);
+ int name_index =
+ Dictionary::EntryToIndex(entry) + Dictionary::kEntryKeyIndex;
+ CHECK_NE(Dictionary::kNotFound, entry);
+
+ Handle<Object> expected_name_index(Smi::FromInt(name_index), isolate);
+ ft.CheckTrue(dictionary, keys[i], expect_found, expected_name_index);
+ }
+
+ Handle<Name> non_existing_keys[] = {
+ factory->InternalizeUtf8String("1"),
+ factory->InternalizeUtf8String("-42"),
+ factory->InternalizeUtf8String("153"),
+ factory->InternalizeUtf8String("-1.0"),
+ factory->InternalizeUtf8String("1.3"),
+ factory->InternalizeUtf8String("a"),
+ factory->InternalizeUtf8String("boom"),
+ factory->NewSymbol(),
+ factory->NewPrivateSymbol(),
+ };
+
+ for (size_t i = 0; i < arraysize(non_existing_keys); i++) {
+ int entry = dictionary->FindEntry(non_existing_keys[i]);
+ CHECK_EQ(Dictionary::kNotFound, entry);
+
+ ft.CheckTrue(dictionary, non_existing_keys[i], expect_not_found);
+ }
+}
+
+} // namespace
+
+TEST(NameDictionaryLookup) { TestNameDictionaryLookup<NameDictionary>(); }
+
+TEST(GlobalDictionaryLookup) { TestNameDictionaryLookup<GlobalDictionary>(); }
+
+namespace {
+
+template <typename Dictionary>
+void TestNumberDictionaryLookup() {
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+
+ const int kNumParams = 4;
+ CodeStubAssemblerTester m(isolate, kNumParams);
+
+ enum Result { kFound, kNotFound };
+ {
+ Node* dictionary = m.Parameter(0);
+ Node* key = m.SmiToWord32(m.Parameter(1));
+ Node* expected_result = m.Parameter(2);
+ Node* expected_arg = m.Parameter(3);
+
+ Label passed(&m), failed(&m);
+ Label if_found(&m), if_not_found(&m);
+ Variable var_entry(&m, MachineRepresentation::kWord32);
+
+ m.NumberDictionaryLookup<Dictionary>(dictionary, key, &if_found, &var_entry,
+ &if_not_found);
+ m.Bind(&if_found);
+ m.GotoUnless(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kFound))),
+ &failed);
+ m.Branch(m.Word32Equal(m.SmiToWord32(expected_arg), var_entry.value()),
+ &passed, &failed);
+
+ m.Bind(&if_not_found);
+ m.Branch(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kNotFound))),
+ &passed, &failed);
+
+ m.Bind(&passed);
+ m.Return(m.BooleanConstant(true));
+
+ m.Bind(&failed);
+ m.Return(m.BooleanConstant(false));
+ }
+
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<Object> expect_found(Smi::FromInt(kFound), isolate);
+ Handle<Object> expect_not_found(Smi::FromInt(kNotFound), isolate);
+
+ const int kKeysCount = 1000;
+ Handle<Dictionary> dictionary = Dictionary::New(isolate, kKeysCount);
+ uint32_t keys[kKeysCount];
+
+ Handle<Object> fake_value(Smi::FromInt(42), isolate);
+ PropertyDetails fake_details = PropertyDetails::Empty();
+
+ base::RandomNumberGenerator rand_gen(FLAG_random_seed);
+
+ for (int i = 0; i < kKeysCount; i++) {
+ int random_key = rand_gen.NextInt(Smi::kMaxValue);
+ keys[i] = static_cast<uint32_t>(random_key);
+ if (dictionary->FindEntry(keys[i]) != Dictionary::kNotFound) continue;
+
+ dictionary = Dictionary::Add(dictionary, keys[i], fake_value, fake_details);
+ }
+
+ // Now try querying existing keys.
+ for (int i = 0; i < kKeysCount; i++) {
+ int entry = dictionary->FindEntry(keys[i]);
+ CHECK_NE(Dictionary::kNotFound, entry);
+
+ Handle<Object> key(Smi::FromInt(keys[i]), isolate);
+ Handle<Object> expected_entry(Smi::FromInt(entry), isolate);
+ ft.CheckTrue(dictionary, key, expect_found, expected_entry);
+ }
+
+ // Now try querying random keys which do not exist in the dictionary.
+ for (int i = 0; i < kKeysCount;) {
+ int random_key = rand_gen.NextInt(Smi::kMaxValue);
+ int entry = dictionary->FindEntry(random_key);
+ if (entry != Dictionary::kNotFound) continue;
+ i++;
+
+ Handle<Object> key(Smi::FromInt(random_key), isolate);
+ ft.CheckTrue(dictionary, key, expect_not_found);
+ }
+}
+
+} // namespace
+
+TEST(SeededNumberDictionaryLookup) {
+ TestNumberDictionaryLookup<SeededNumberDictionary>();
+}
+
+TEST(UnseededNumberDictionaryLookup) {
+ TestNumberDictionaryLookup<UnseededNumberDictionary>();
+}
+
+namespace {
+
+void AddProperties(Handle<JSObject> object, Handle<Name> names[],
+ size_t count) {
+ Isolate* isolate = object->GetIsolate();
+ for (size_t i = 0; i < count; i++) {
+ Handle<Object> value(Smi::FromInt(static_cast<int>(42 + i)), isolate);
+ JSObject::AddProperty(object, names[i], value, NONE);
+ }
+}
+
+Handle<AccessorPair> CreateAccessorPair(FunctionTester* ft,
+ const char* getter_body,
+ const char* setter_body) {
+ Handle<AccessorPair> pair = ft->isolate->factory()->NewAccessorPair();
+ if (getter_body) {
+ pair->set_getter(*ft->NewFunction(getter_body));
+ }
+ if (setter_body) {
+ pair->set_setter(*ft->NewFunction(setter_body));
+ }
+ return pair;
+}
+
+void AddProperties(Handle<JSObject> object, Handle<Name> names[],
+ size_t names_count, Handle<Object> values[],
+ size_t values_count, int seed = 0) {
+ Isolate* isolate = object->GetIsolate();
+ for (size_t i = 0; i < names_count; i++) {
+ Handle<Object> value = values[(seed + i) % values_count];
+ if (value->IsAccessorPair()) {
+ Handle<AccessorPair> pair = Handle<AccessorPair>::cast(value);
+ Handle<Object> getter(pair->getter(), isolate);
+ Handle<Object> setter(pair->setter(), isolate);
+ JSObject::DefineAccessor(object, names[i], getter, setter, NONE).Check();
+ } else {
+ JSObject::AddProperty(object, names[i], value, NONE);
+ }
+ }
+}
+
+} // namespace
+
+TEST(TryHasOwnProperty) {
+ typedef CodeStubAssembler::Label Label;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+
+ const int kNumParams = 4;
+ CodeStubAssemblerTester m(isolate, kNumParams);
+
+ enum Result { kFound, kNotFound, kBailout };
+ {
+ Node* object = m.Parameter(0);
+ Node* unique_name = m.Parameter(1);
+ Node* expected_result = m.Parameter(2);
+
+ Label passed(&m), failed(&m);
+ Label if_found(&m), if_not_found(&m), if_bailout(&m);
+
+ Node* map = m.LoadMap(object);
+ Node* instance_type = m.LoadMapInstanceType(map);
+
+ m.TryHasOwnProperty(object, map, instance_type, unique_name, &if_found,
+ &if_not_found, &if_bailout);
+
+ m.Bind(&if_found);
+ m.Branch(m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kFound))),
+ &passed, &failed);
+
+ m.Bind(&if_not_found);
+ m.Branch(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kNotFound))),
+ &passed, &failed);
+
+ m.Bind(&if_bailout);
+ m.Branch(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kBailout))),
+ &passed, &failed);
+
+ m.Bind(&passed);
+ m.Return(m.BooleanConstant(true));
+
+ m.Bind(&failed);
+ m.Return(m.BooleanConstant(false));
+ }
+
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<Object> expect_found(Smi::FromInt(kFound), isolate);
+ Handle<Object> expect_not_found(Smi::FromInt(kNotFound), isolate);
+ Handle<Object> expect_bailout(Smi::FromInt(kBailout), isolate);
+
+ Factory* factory = isolate->factory();
+
+ Handle<Name> deleted_property_name =
+ factory->InternalizeUtf8String("deleted");
+
+ Handle<Name> names[] = {
+ factory->InternalizeUtf8String("a"),
+ factory->InternalizeUtf8String("bb"),
+ factory->InternalizeUtf8String("ccc"),
+ factory->InternalizeUtf8String("dddd"),
+ factory->InternalizeUtf8String("eeeee"),
+ factory->InternalizeUtf8String(""),
+ factory->InternalizeUtf8String("name"),
+ factory->NewSymbol(),
+ factory->NewPrivateSymbol(),
+ };
+
+ std::vector<Handle<JSObject>> objects;
+
+ {
+ // Fast object, no inobject properties.
+ int inobject_properties = 0;
+ Handle<Map> map = Map::Create(isolate, inobject_properties);
+ Handle<JSObject> object = factory->NewJSObjectFromMap(map);
+ AddProperties(object, names, arraysize(names));
+ CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+ CHECK_EQ(inobject_properties, object->map()->GetInObjectProperties());
+ CHECK(!object->map()->is_dictionary_map());
+ objects.push_back(object);
+ }
+
+ {
+ // Fast object, all inobject properties.
+ int inobject_properties = arraysize(names) * 2;
+ Handle<Map> map = Map::Create(isolate, inobject_properties);
+ Handle<JSObject> object = factory->NewJSObjectFromMap(map);
+ AddProperties(object, names, arraysize(names));
+ CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+ CHECK_EQ(inobject_properties, object->map()->GetInObjectProperties());
+ CHECK(!object->map()->is_dictionary_map());
+ objects.push_back(object);
+ }
+
+ {
+ // Fast object, half inobject properties.
+ int inobject_properties = arraysize(names) / 2;
+ Handle<Map> map = Map::Create(isolate, inobject_properties);
+ Handle<JSObject> object = factory->NewJSObjectFromMap(map);
+ AddProperties(object, names, arraysize(names));
+ CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+ CHECK_EQ(inobject_properties, object->map()->GetInObjectProperties());
+ CHECK(!object->map()->is_dictionary_map());
+ objects.push_back(object);
+ }
+
+ {
+ // Dictionary mode object.
+ Handle<JSFunction> function = factory->NewFunction(factory->empty_string());
+ Handle<JSObject> object = factory->NewJSObject(function);
+ AddProperties(object, names, arraysize(names));
+ JSObject::NormalizeProperties(object, CLEAR_INOBJECT_PROPERTIES, 0, "test");
+
+ JSObject::AddProperty(object, deleted_property_name, object, NONE);
+ CHECK(JSObject::DeleteProperty(object, deleted_property_name, SLOPPY)
+ .FromJust());
+
+ CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+ CHECK(object->map()->is_dictionary_map());
+ objects.push_back(object);
+ }
+
+ {
+ // Global object.
+ Handle<JSFunction> function = factory->NewFunction(factory->empty_string());
+ JSFunction::EnsureHasInitialMap(function);
+ function->initial_map()->set_instance_type(JS_GLOBAL_OBJECT_TYPE);
+ function->initial_map()->set_is_prototype_map(true);
+ function->initial_map()->set_dictionary_map(true);
+ Handle<JSObject> object = factory->NewJSGlobalObject(function);
+ AddProperties(object, names, arraysize(names));
+
+ JSObject::AddProperty(object, deleted_property_name, object, NONE);
+ CHECK(JSObject::DeleteProperty(object, deleted_property_name, SLOPPY)
+ .FromJust());
+
+ CHECK_EQ(JS_GLOBAL_OBJECT_TYPE, object->map()->instance_type());
+ CHECK(object->map()->is_dictionary_map());
+ objects.push_back(object);
+ }
+
+ {
+ for (Handle<JSObject> object : objects) {
+ for (size_t name_index = 0; name_index < arraysize(names); name_index++) {
+ Handle<Name> name = names[name_index];
+ CHECK(JSReceiver::HasProperty(object, name).FromJust());
+ ft.CheckTrue(object, name, expect_found);
+ }
+ }
+ }
+
+ {
+ Handle<Name> non_existing_names[] = {
+ factory->NewSymbol(),
+ factory->InternalizeUtf8String("ne_a"),
+ factory->InternalizeUtf8String("ne_bb"),
+ factory->NewPrivateSymbol(),
+ factory->InternalizeUtf8String("ne_ccc"),
+ factory->InternalizeUtf8String("ne_dddd"),
+ deleted_property_name,
+ };
+ for (Handle<JSObject> object : objects) {
+ for (size_t key_index = 0; key_index < arraysize(non_existing_names);
+ key_index++) {
+ Handle<Name> name = non_existing_names[key_index];
+ CHECK(!JSReceiver::HasProperty(object, name).FromJust());
+ ft.CheckTrue(object, name, expect_not_found);
+ }
+ }
+ }
+
+ {
+ Handle<JSFunction> function = factory->NewFunction(factory->empty_string());
+ Handle<JSProxy> object = factory->NewJSProxy(function, objects[0]);
+ CHECK_EQ(JS_PROXY_TYPE, object->map()->instance_type());
+ ft.CheckTrue(object, names[0], expect_bailout);
+ }
+
+ {
+ Handle<JSObject> object = isolate->global_proxy();
+ CHECK_EQ(JS_GLOBAL_PROXY_TYPE, object->map()->instance_type());
+ ft.CheckTrue(object, names[0], expect_bailout);
+ }
+}
+
+TEST(TryGetOwnProperty) {
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ Factory* factory = isolate->factory();
+
+ const int kNumParams = 2;
+ CodeStubAssemblerTester m(isolate, kNumParams);
+
+ Handle<Symbol> not_found_symbol = factory->NewSymbol();
+ Handle<Symbol> bailout_symbol = factory->NewSymbol();
+ {
+ Node* object = m.Parameter(0);
+ Node* unique_name = m.Parameter(1);
+ Node* context = m.Parameter(kNumParams + 2);
+
+ Variable var_value(&m, MachineRepresentation::kTagged);
+ Label if_found(&m), if_not_found(&m), if_bailout(&m);
+
+ Node* map = m.LoadMap(object);
+ Node* instance_type = m.LoadMapInstanceType(map);
+
+ m.TryGetOwnProperty(context, object, object, map, instance_type,
+ unique_name, &if_found, &var_value, &if_not_found,
+ &if_bailout);
+
+ m.Bind(&if_found);
+ m.Return(var_value.value());
+
+ m.Bind(&if_not_found);
+ m.Return(m.HeapConstant(not_found_symbol));
+
+ m.Bind(&if_bailout);
+ m.Return(m.HeapConstant(bailout_symbol));
+ }
+
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Handle<Name> deleted_property_name =
+ factory->InternalizeUtf8String("deleted");
+
+ Handle<Name> names[] = {
+ factory->InternalizeUtf8String("bb"),
+ factory->NewSymbol(),
+ factory->InternalizeUtf8String("a"),
+ factory->InternalizeUtf8String("ccc"),
+ factory->InternalizeUtf8String("esajefe"),
+ factory->NewPrivateSymbol(),
+ factory->InternalizeUtf8String("eeeee"),
+ factory->InternalizeUtf8String("p1"),
+ factory->InternalizeUtf8String("acshw23e"),
+ factory->InternalizeUtf8String(""),
+ factory->InternalizeUtf8String("dddd"),
+ factory->NewPrivateSymbol(),
+ factory->InternalizeUtf8String("name"),
+ factory->InternalizeUtf8String("p2"),
+ factory->InternalizeUtf8String("p3"),
+ factory->InternalizeUtf8String("p4"),
+ factory->NewPrivateSymbol(),
+ };
+ Handle<Object> values[] = {
+ factory->NewFunction(factory->empty_string()),
+ factory->NewSymbol(),
+ factory->InternalizeUtf8String("a"),
+ CreateAccessorPair(&ft, "() => 188;", "() => 199;"),
+ factory->NewFunction(factory->InternalizeUtf8String("bb")),
+ factory->InternalizeUtf8String("ccc"),
+ CreateAccessorPair(&ft, "() => 88;", nullptr),
+ handle(Smi::FromInt(1), isolate),
+ factory->InternalizeUtf8String(""),
+ CreateAccessorPair(&ft, nullptr, "() => 99;"),
+ factory->NewHeapNumber(4.2),
+ handle(Smi::FromInt(153), isolate),
+ factory->NewJSObject(factory->NewFunction(factory->empty_string())),
+ factory->NewPrivateSymbol(),
+ };
+ STATIC_ASSERT(arraysize(values) < arraysize(names));
+
+ base::RandomNumberGenerator rand_gen(FLAG_random_seed);
+
+ std::vector<Handle<JSObject>> objects;
+
+ {
+ // Fast object, no inobject properties.
+ int inobject_properties = 0;
+ Handle<Map> map = Map::Create(isolate, inobject_properties);
+ Handle<JSObject> object = factory->NewJSObjectFromMap(map);
+ AddProperties(object, names, arraysize(names), values, arraysize(values),
+ rand_gen.NextInt());
+ CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+ CHECK_EQ(inobject_properties, object->map()->GetInObjectProperties());
+ CHECK(!object->map()->is_dictionary_map());
+ objects.push_back(object);
+ }
+
+ {
+ // Fast object, all inobject properties.
+ int inobject_properties = arraysize(names) * 2;
+ Handle<Map> map = Map::Create(isolate, inobject_properties);
+ Handle<JSObject> object = factory->NewJSObjectFromMap(map);
+ AddProperties(object, names, arraysize(names), values, arraysize(values),
+ rand_gen.NextInt());
+ CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+ CHECK_EQ(inobject_properties, object->map()->GetInObjectProperties());
+ CHECK(!object->map()->is_dictionary_map());
+ objects.push_back(object);
+ }
+
+ {
+ // Fast object, half inobject properties.
+ int inobject_properties = arraysize(names) / 2;
+ Handle<Map> map = Map::Create(isolate, inobject_properties);
+ Handle<JSObject> object = factory->NewJSObjectFromMap(map);
+ AddProperties(object, names, arraysize(names), values, arraysize(values),
+ rand_gen.NextInt());
+ CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+ CHECK_EQ(inobject_properties, object->map()->GetInObjectProperties());
+ CHECK(!object->map()->is_dictionary_map());
+ objects.push_back(object);
+ }
+
+ {
+ // Dictionary mode object.
+ Handle<JSFunction> function = factory->NewFunction(factory->empty_string());
+ Handle<JSObject> object = factory->NewJSObject(function);
+ AddProperties(object, names, arraysize(names), values, arraysize(values),
+ rand_gen.NextInt());
+ JSObject::NormalizeProperties(object, CLEAR_INOBJECT_PROPERTIES, 0, "test");
+
+ JSObject::AddProperty(object, deleted_property_name, object, NONE);
+ CHECK(JSObject::DeleteProperty(object, deleted_property_name, SLOPPY)
+ .FromJust());
+
+ CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+ CHECK(object->map()->is_dictionary_map());
+ objects.push_back(object);
+ }
+
+ {
+ // Global object.
+ Handle<JSGlobalObject> object = isolate->global_object();
+ AddProperties(object, names, arraysize(names), values, arraysize(values),
+ rand_gen.NextInt());
+
+ JSObject::AddProperty(object, deleted_property_name, object, NONE);
+ CHECK(JSObject::DeleteProperty(object, deleted_property_name, SLOPPY)
+ .FromJust());
+
+ CHECK_EQ(JS_GLOBAL_OBJECT_TYPE, object->map()->instance_type());
+ CHECK(object->map()->is_dictionary_map());
+ objects.push_back(object);
+ }
+
+ // TODO(ishell): test proxy and interceptors when they are supported.
+
+ {
+ for (Handle<JSObject> object : objects) {
+ for (size_t name_index = 0; name_index < arraysize(names); name_index++) {
+ Handle<Name> name = names[name_index];
+ Handle<Object> expected_value =
+ JSReceiver::GetProperty(object, name).ToHandleChecked();
+ Handle<Object> value = ft.Call(object, name).ToHandleChecked();
+ CHECK(expected_value->SameValue(*value));
+ }
+ }
+ }
+
+ {
+ Handle<Name> non_existing_names[] = {
+ factory->NewSymbol(),
+ factory->InternalizeUtf8String("ne_a"),
+ factory->InternalizeUtf8String("ne_bb"),
+ factory->NewPrivateSymbol(),
+ factory->InternalizeUtf8String("ne_ccc"),
+ factory->InternalizeUtf8String("ne_dddd"),
+ deleted_property_name,
+ };
+ for (Handle<JSObject> object : objects) {
+ for (size_t key_index = 0; key_index < arraysize(non_existing_names);
+ key_index++) {
+ Handle<Name> name = non_existing_names[key_index];
+ Handle<Object> expected_value =
+ JSReceiver::GetProperty(object, name).ToHandleChecked();
+ CHECK(expected_value->IsUndefined(isolate));
+ Handle<Object> value = ft.Call(object, name).ToHandleChecked();
+ CHECK_EQ(*not_found_symbol, *value);
+ }
+ }
+ }
+
+ {
+ Handle<JSFunction> function = factory->NewFunction(factory->empty_string());
+ Handle<JSProxy> object = factory->NewJSProxy(function, objects[0]);
+ CHECK_EQ(JS_PROXY_TYPE, object->map()->instance_type());
+ Handle<Object> value = ft.Call(object, names[0]).ToHandleChecked();
+ // Proxies are not supported yet.
+ CHECK_EQ(*bailout_symbol, *value);
+ }
+
+ {
+ Handle<JSObject> object = isolate->global_proxy();
+ CHECK_EQ(JS_GLOBAL_PROXY_TYPE, object->map()->instance_type());
+ // Global proxies are not supported yet.
+ Handle<Object> value = ft.Call(object, names[0]).ToHandleChecked();
+ CHECK_EQ(*bailout_symbol, *value);
+ }
+}
+
+namespace {
+
+void AddElement(Handle<JSObject> object, uint32_t index, Handle<Object> value,
+ PropertyAttributes attributes = NONE) {
+ JSObject::AddDataElement(object, index, value, attributes).ToHandleChecked();
+}
+
+} // namespace
+
+TEST(TryLookupElement) {
+ typedef CodeStubAssembler::Label Label;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+
+ const int kNumParams = 3;
+ CodeStubAssemblerTester m(isolate, kNumParams);
+
+ enum Result { kFound, kNotFound, kBailout };
+ {
+ Node* object = m.Parameter(0);
+ Node* index = m.SmiToWord32(m.Parameter(1));
+ Node* expected_result = m.Parameter(2);
+
+ Label passed(&m), failed(&m);
+ Label if_found(&m), if_not_found(&m), if_bailout(&m);
+
+ Node* map = m.LoadMap(object);
+ Node* instance_type = m.LoadMapInstanceType(map);
+
+ m.TryLookupElement(object, map, instance_type, index, &if_found,
+ &if_not_found, &if_bailout);
+
+ m.Bind(&if_found);
+ m.Branch(m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kFound))),
+ &passed, &failed);
+
+ m.Bind(&if_not_found);
+ m.Branch(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kNotFound))),
+ &passed, &failed);
+
+ m.Bind(&if_bailout);
+ m.Branch(
+ m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kBailout))),
+ &passed, &failed);
+
+ m.Bind(&passed);
+ m.Return(m.BooleanConstant(true));
+
+ m.Bind(&failed);
+ m.Return(m.BooleanConstant(false));
+ }
+
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Factory* factory = isolate->factory();
+ Handle<Object> smi0(Smi::FromInt(0), isolate);
+ Handle<Object> smi1(Smi::FromInt(1), isolate);
+ Handle<Object> smi7(Smi::FromInt(7), isolate);
+ Handle<Object> smi13(Smi::FromInt(13), isolate);
+ Handle<Object> smi42(Smi::FromInt(42), isolate);
+
+ Handle<Object> expect_found(Smi::FromInt(kFound), isolate);
+ Handle<Object> expect_not_found(Smi::FromInt(kNotFound), isolate);
+ Handle<Object> expect_bailout(Smi::FromInt(kBailout), isolate);
+
+#define CHECK_FOUND(object, index) \
+ CHECK(JSReceiver::HasElement(object, index).FromJust()); \
+ ft.CheckTrue(object, smi##index, expect_found);
+
+#define CHECK_NOT_FOUND(object, index) \
+ CHECK(!JSReceiver::HasElement(object, index).FromJust()); \
+ ft.CheckTrue(object, smi##index, expect_not_found);
+
+ {
+ Handle<JSArray> object = factory->NewJSArray(0, FAST_SMI_ELEMENTS);
+ AddElement(object, 0, smi0);
+ AddElement(object, 1, smi0);
+ CHECK_EQ(FAST_SMI_ELEMENTS, object->map()->elements_kind());
+
+ CHECK_FOUND(object, 0);
+ CHECK_FOUND(object, 1);
+ CHECK_NOT_FOUND(object, 7);
+ CHECK_NOT_FOUND(object, 13);
+ CHECK_NOT_FOUND(object, 42);
+ }
+
+ {
+ Handle<JSArray> object = factory->NewJSArray(0, FAST_HOLEY_SMI_ELEMENTS);
+ AddElement(object, 0, smi0);
+ AddElement(object, 13, smi0);
+ CHECK_EQ(FAST_HOLEY_SMI_ELEMENTS, object->map()->elements_kind());
+
+ CHECK_FOUND(object, 0);
+ CHECK_NOT_FOUND(object, 1);
+ CHECK_NOT_FOUND(object, 7);
+ CHECK_FOUND(object, 13);
+ CHECK_NOT_FOUND(object, 42);
+ }
+
+ {
+ Handle<JSArray> object = factory->NewJSArray(0, FAST_ELEMENTS);
+ AddElement(object, 0, smi0);
+ AddElement(object, 1, smi0);
+ CHECK_EQ(FAST_ELEMENTS, object->map()->elements_kind());
+
+ CHECK_FOUND(object, 0);
+ CHECK_FOUND(object, 1);
+ CHECK_NOT_FOUND(object, 7);
+ CHECK_NOT_FOUND(object, 13);
+ CHECK_NOT_FOUND(object, 42);
+ }
+
+ {
+ Handle<JSArray> object = factory->NewJSArray(0, FAST_HOLEY_ELEMENTS);
+ AddElement(object, 0, smi0);
+ AddElement(object, 13, smi0);
+ CHECK_EQ(FAST_HOLEY_ELEMENTS, object->map()->elements_kind());
+
+ CHECK_FOUND(object, 0);
+ CHECK_NOT_FOUND(object, 1);
+ CHECK_NOT_FOUND(object, 7);
+ CHECK_FOUND(object, 13);
+ CHECK_NOT_FOUND(object, 42);
+ }
+
+ {
+ Handle<JSFunction> constructor = isolate->string_function();
+ Handle<JSObject> object = factory->NewJSObject(constructor);
+ Handle<String> str = factory->InternalizeUtf8String("ab");
+ Handle<JSValue>::cast(object)->set_value(*str);
+ AddElement(object, 13, smi0);
+ CHECK_EQ(FAST_STRING_WRAPPER_ELEMENTS, object->map()->elements_kind());
+
+ CHECK_FOUND(object, 0);
+ CHECK_FOUND(object, 1);
+ CHECK_NOT_FOUND(object, 7);
+ CHECK_FOUND(object, 13);
+ CHECK_NOT_FOUND(object, 42);
+ }
+
+ {
+ Handle<JSFunction> constructor = isolate->string_function();
+ Handle<JSObject> object = factory->NewJSObject(constructor);
+ Handle<String> str = factory->InternalizeUtf8String("ab");
+ Handle<JSValue>::cast(object)->set_value(*str);
+ AddElement(object, 13, smi0);
+ JSObject::NormalizeElements(object);
+ CHECK_EQ(SLOW_STRING_WRAPPER_ELEMENTS, object->map()->elements_kind());
+
+ CHECK_FOUND(object, 0);
+ CHECK_FOUND(object, 1);
+ CHECK_NOT_FOUND(object, 7);
+ CHECK_FOUND(object, 13);
+ CHECK_NOT_FOUND(object, 42);
+ }
+
+// TODO(ishell): uncomment once NO_ELEMENTS kind is supported.
+// {
+// Handle<Map> map = Map::Create(isolate, 0);
+// map->set_elements_kind(NO_ELEMENTS);
+// Handle<JSObject> object = factory->NewJSObjectFromMap(map);
+// CHECK_EQ(NO_ELEMENTS, object->map()->elements_kind());
+//
+// CHECK_NOT_FOUND(object, 0);
+// CHECK_NOT_FOUND(object, 1);
+// CHECK_NOT_FOUND(object, 7);
+// CHECK_NOT_FOUND(object, 13);
+// CHECK_NOT_FOUND(object, 42);
+// }
+
+#undef CHECK_FOUND
+#undef CHECK_NOT_FOUND
+
+ {
+ Handle<JSArray> handler = factory->NewJSArray(0);
+ Handle<JSFunction> function = factory->NewFunction(factory->empty_string());
+ Handle<JSProxy> object = factory->NewJSProxy(function, handler);
+ CHECK_EQ(JS_PROXY_TYPE, object->map()->instance_type());
+ ft.CheckTrue(object, smi0, expect_bailout);
+ }
+
+ {
+ Handle<JSObject> object = isolate->global_object();
+ CHECK_EQ(JS_GLOBAL_OBJECT_TYPE, object->map()->instance_type());
+ ft.CheckTrue(object, smi0, expect_bailout);
+ }
+
+ {
+ Handle<JSObject> object = isolate->global_proxy();
+ CHECK_EQ(JS_GLOBAL_PROXY_TYPE, object->map()->instance_type());
+ ft.CheckTrue(object, smi0, expect_bailout);
+ }
+}
+
+TEST(DeferredCodePhiHints) {
+ typedef compiler::Node Node;
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeStubAssemblerTester m(isolate, descriptor);
+ Label block1(&m, Label::kDeferred);
+ m.Goto(&block1);
+ m.Bind(&block1);
+ {
+ Variable var_object(&m, MachineRepresentation::kTagged);
+ Label loop(&m, &var_object);
+ var_object.Bind(m.IntPtrConstant(0));
+ m.Goto(&loop);
+ m.Bind(&loop);
+ {
+ Node* map = m.LoadMap(var_object.value());
+ var_object.Bind(map);
+ m.Goto(&loop);
+ }
+ }
+ CHECK(!m.GenerateCode().is_null());
+}
+
+TEST(TestOutOfScopeVariable) {
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ VoidDescriptor descriptor(isolate);
+ CodeStubAssemblerTester m(isolate, descriptor);
+ Label block1(&m);
+ Label block2(&m);
+ Label block3(&m);
+ Label block4(&m);
+ m.Branch(m.WordEqual(m.Parameter(0), m.IntPtrConstant(0)), &block1, &block4);
+ m.Bind(&block4);
+ {
+ Variable var_object(&m, MachineRepresentation::kTagged);
+ m.Branch(m.WordEqual(m.Parameter(0), m.IntPtrConstant(0)), &block2,
+ &block3);
+
+ m.Bind(&block2);
+ var_object.Bind(m.IntPtrConstant(55));
+ m.Goto(&block1);
+
+ m.Bind(&block3);
+ var_object.Bind(m.IntPtrConstant(66));
+ m.Goto(&block1);
+ }
+ m.Bind(&block1);
+ CHECK(!m.GenerateCode().is_null());
+}
+
+namespace {
+
+void TestStubCacheOffsetCalculation(StubCache::Table table,
+ Code::Kind handler_kind) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ const int kNumParams = 2;
+ CodeStubAssemblerTester m(isolate, kNumParams);
+
+ Code::Flags code_flags =
+ Code::RemoveHolderFromFlags(Code::ComputeHandlerFlags(handler_kind));
+ {
+ Node* name = m.Parameter(0);
+ Node* map = m.Parameter(1);
+ Node* primary_offset = m.StubCachePrimaryOffset(name, code_flags, map);
+ Node* result;
+ if (table == StubCache::kPrimary) {
+ result = primary_offset;
+ } else {
+ CHECK_EQ(StubCache::kSecondary, table);
+ result = m.StubCacheSecondaryOffset(name, code_flags, primary_offset);
+ }
+ m.Return(m.SmiFromWord32(result));
+ }
+
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ Factory* factory = isolate->factory();
+ Handle<Name> names[] = {
+ factory->NewSymbol(),
+ factory->InternalizeUtf8String("a"),
+ factory->InternalizeUtf8String("bb"),
+ factory->InternalizeUtf8String("ccc"),
+ factory->NewPrivateSymbol(),
+ factory->InternalizeUtf8String("dddd"),
+ factory->InternalizeUtf8String("eeeee"),
+ factory->InternalizeUtf8String("name"),
+ factory->NewSymbol(),
+ factory->NewPrivateSymbol(),
+ };
+
+ Handle<Map> maps[] = {
+ Handle<Map>(nullptr, isolate),
+ factory->cell_map(),
+ Map::Create(isolate, 0),
+ factory->meta_map(),
+ factory->code_map(),
+ Map::Create(isolate, 0),
+ factory->hash_table_map(),
+ factory->symbol_map(),
+ factory->string_map(),
+ Map::Create(isolate, 0),
+ factory->sloppy_arguments_elements_map(),
+ };
+
+ for (int name_index = 0; name_index < arraysize(names); name_index++) {
+ Handle<Name> name = names[name_index];
+ for (int map_index = 0; map_index < arraysize(maps); map_index++) {
+ Handle<Map> map = maps[map_index];
+
+ int expected_result;
+ {
+ int primary_offset =
+ StubCache::PrimaryOffsetForTesting(*name, code_flags, *map);
+ if (table == StubCache::kPrimary) {
+ expected_result = primary_offset;
+ } else {
+ expected_result = StubCache::SecondaryOffsetForTesting(
+ *name, code_flags, primary_offset);
+ }
+ }
+ Handle<Object> result = ft.Call(name, map).ToHandleChecked();
+
+ Smi* expected = Smi::FromInt(expected_result & Smi::kMaxValue);
+ CHECK_EQ(expected, Smi::cast(*result));
+ }
+ }
+}
+
+} // namespace
+
+TEST(StubCachePrimaryOffsetLoadIC) {
+ TestStubCacheOffsetCalculation(StubCache::kPrimary, Code::LOAD_IC);
+}
+
+TEST(StubCachePrimaryOffsetStoreIC) {
+ TestStubCacheOffsetCalculation(StubCache::kPrimary, Code::STORE_IC);
+}
+
+TEST(StubCacheSecondaryOffsetLoadIC) {
+ TestStubCacheOffsetCalculation(StubCache::kSecondary, Code::LOAD_IC);
+}
+
+TEST(StubCacheSecondaryOffsetStoreIC) {
+ TestStubCacheOffsetCalculation(StubCache::kSecondary, Code::STORE_IC);
+}
+
+namespace {
+
+Handle<Code> CreateCodeWithFlags(Code::Flags flags) {
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ CodeStubAssemblerTester m(isolate, flags);
+ m.Return(m.UndefinedConstant());
+ return m.GenerateCodeCloseAndEscape();
+}
+
+} // namespace
+
+TEST(TryProbeStubCache) {
+ typedef CodeStubAssembler::Label Label;
+ typedef CodeStubAssembler::Variable Variable;
+ Isolate* isolate(CcTest::InitIsolateOnce());
+ const int kNumParams = 3;
+ CodeStubAssemblerTester m(isolate, kNumParams);
+
+ Code::Flags flags_to_query =
+ Code::RemoveHolderFromFlags(Code::ComputeHandlerFlags(Code::LOAD_IC));
+
+ StubCache stub_cache(isolate);
+ stub_cache.Clear();
+
+ {
+ Node* receiver = m.Parameter(0);
+ Node* name = m.Parameter(1);
+ Node* expected_handler = m.Parameter(2);
+
+ Label passed(&m), failed(&m);
+
+ Variable var_handler(&m, MachineRepresentation::kTagged);
+ Label if_handler(&m), if_miss(&m);
+
+ m.TryProbeStubCache(&stub_cache, flags_to_query, receiver, name,
+ &if_handler, &var_handler, &if_miss);
+ m.Bind(&if_handler);
+ m.BranchIfWordEqual(expected_handler, var_handler.value(), &passed,
+ &failed);
+
+ m.Bind(&if_miss);
+ m.BranchIfWordEqual(expected_handler, m.IntPtrConstant(0), &passed,
+ &failed);
+
+ m.Bind(&passed);
+ m.Return(m.BooleanConstant(true));
+
+ m.Bind(&failed);
+ m.Return(m.BooleanConstant(false));
+ }
+
+ Handle<Code> code = m.GenerateCode();
+ FunctionTester ft(code, kNumParams);
+
+ std::vector<Handle<Name>> names;
+ std::vector<Handle<JSObject>> receivers;
+ std::vector<Handle<Code>> handlers;
+
+ base::RandomNumberGenerator rand_gen(FLAG_random_seed);
+
+ Factory* factory = isolate->factory();
+
+ // Generate some number of names.
+ for (int i = 0; i < StubCache::kPrimaryTableSize / 7; i++) {
+ Handle<Name> name;
+ switch (rand_gen.NextInt(3)) {
+ case 0: {
+ // Generate string.
+ std::stringstream ss;
+ ss << "s" << std::hex
+ << (rand_gen.NextInt(Smi::kMaxValue) % StubCache::kPrimaryTableSize);
+ name = factory->InternalizeUtf8String(ss.str().c_str());
+ break;
+ }
+ case 1: {
+ // Generate number string.
+ std::stringstream ss;
+ ss << (rand_gen.NextInt(Smi::kMaxValue) % StubCache::kPrimaryTableSize);
+ name = factory->InternalizeUtf8String(ss.str().c_str());
+ break;
+ }
+ case 2: {
+ // Generate symbol.
+ name = factory->NewSymbol();
+ break;
+ }
+ default:
+ UNREACHABLE();
+ }
+ names.push_back(name);
+ }
+
+ // Generate some number of receiver maps and receivers.
+ for (int i = 0; i < StubCache::kSecondaryTableSize / 2; i++) {
+ Handle<Map> map = Map::Create(isolate, 0);
+ receivers.push_back(factory->NewJSObjectFromMap(map));
+ }
+
+ // Generate some number of handlers.
+ for (int i = 0; i < 30; i++) {
+ Code::Kind code_kind;
+ switch (rand_gen.NextInt(4)) {
+ case 0:
+ code_kind = Code::LOAD_IC;
+ break;
+ case 1:
+ code_kind = Code::KEYED_LOAD_IC;
+ break;
+ case 2:
+ code_kind = Code::STORE_IC;
+ break;
+ case 3:
+ code_kind = Code::KEYED_STORE_IC;
+ break;
+ default:
+ UNREACHABLE();
+ }
+ Code::Flags flags =
+ Code::RemoveHolderFromFlags(Code::ComputeHandlerFlags(code_kind));
+ handlers.push_back(CreateCodeWithFlags(flags));
+ }
+
+ // Ensure that GC does happen because from now on we are going to fill our
+ // own stub cache instance with raw values.
+ DisallowHeapAllocation no_gc;
+
+ // Populate {stub_cache}.
+ const int N = StubCache::kPrimaryTableSize + StubCache::kSecondaryTableSize;
+ for (int i = 0; i < N; i++) {
+ int index = rand_gen.NextInt();
+ Handle<Name> name = names[index % names.size()];
+ Handle<JSObject> receiver = receivers[index % receivers.size()];
+ Handle<Code> handler = handlers[index % handlers.size()];
+ stub_cache.Set(*name, receiver->map(), *handler);
+ }
+
+ // Perform some queries.
+ bool queried_existing = false;
+ bool queried_non_existing = false;
+ for (int i = 0; i < N; i++) {
+ int index = rand_gen.NextInt();
+ Handle<Name> name = names[index % names.size()];
+ Handle<JSObject> receiver = receivers[index % receivers.size()];
+ Code* handler = stub_cache.Get(*name, receiver->map(), flags_to_query);
+ if (handler == nullptr) {
+ queried_non_existing = true;
+ } else {
+ queried_existing = true;
+ }
+
+ Handle<Code> expected_handler(handler, isolate);
+ ft.CheckTrue(receiver, name, expected_handler);
+ }
+
+ for (int i = 0; i < N; i++) {
+ int index1 = rand_gen.NextInt();
+ int index2 = rand_gen.NextInt();
+ Handle<Name> name = names[index1 % names.size()];
+ Handle<JSObject> receiver = receivers[index2 % receivers.size()];
+ Code* handler = stub_cache.Get(*name, receiver->map(), flags_to_query);
+ if (handler == nullptr) {
+ queried_non_existing = true;
+ } else {
+ queried_existing = true;
+ }
+
+ Handle<Code> expected_handler(handler, isolate);
+ ft.CheckTrue(receiver, name, expected_handler);
+ }
+ // Ensure we performed both kind of queries.
+ CHECK(queried_existing && queried_non_existing);
+}
+
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/test-code-stubs-arm.cc b/test/cctest/test-code-stubs-arm.cc
index f59d854..0e0a132 100644
--- a/test/cctest/test-code-stubs-arm.cc
+++ b/test/cctest/test-code-stubs-arm.cc
@@ -78,8 +78,9 @@
int source_reg_offset = kDoubleSize;
int reg_num = 0;
for (; reg_num < Register::kNumRegisters; ++reg_num) {
- Register reg = Register::from_code(reg_num);
- if (reg.IsAllocatable()) {
+ if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
+ reg_num)) {
+ Register reg = Register::from_code(reg_num);
if (!reg.is(destination_reg)) {
__ push(reg);
source_reg_offset += kPointerSize;
@@ -107,8 +108,9 @@
// Make sure no registers have been unexpectedly clobbered
for (--reg_num; reg_num >= 0; --reg_num) {
- Register reg = Register::from_code(reg_num);
- if (reg.IsAllocatable()) {
+ if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
+ reg_num)) {
+ Register reg = Register::from_code(reg_num);
if (!reg.is(destination_reg)) {
__ ldr(ip, MemOperand(sp, 0));
__ cmp(reg, ip);
diff --git a/test/cctest/test-code-stubs-arm64.cc b/test/cctest/test-code-stubs-arm64.cc
index f5a4078..2edb923 100644
--- a/test/cctest/test-code-stubs-arm64.cc
+++ b/test/cctest/test-code-stubs-arm64.cc
@@ -74,8 +74,9 @@
int source_reg_offset = kDoubleSize;
int reg_num = 0;
for (; reg_num < Register::kNumRegisters; ++reg_num) {
- Register reg = Register::from_code(reg_num);
- if (reg.IsAllocatable()) {
+ if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
+ reg_num)) {
+ Register reg = Register::from_code(reg_num);
if (!reg.is(destination_reg)) {
queue.Queue(reg);
source_reg_offset += kPointerSize;
@@ -103,8 +104,9 @@
// // Make sure no registers have been unexpectedly clobbered
for (--reg_num; reg_num >= 0; --reg_num) {
- Register reg = Register::from_code(reg_num);
- if (reg.IsAllocatable()) {
+ if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
+ reg_num)) {
+ Register reg = Register::from_code(reg_num);
if (!reg.is(destination_reg)) {
__ Pop(ip0);
__ cmp(reg, ip0);
diff --git a/test/cctest/test-code-stubs-ia32.cc b/test/cctest/test-code-stubs-ia32.cc
index efc39e9..5a420b1 100644
--- a/test/cctest/test-code-stubs-ia32.cc
+++ b/test/cctest/test-code-stubs-ia32.cc
@@ -72,8 +72,9 @@
// Save registers make sure they don't get clobbered.
int reg_num = 0;
for (; reg_num < Register::kNumRegisters; ++reg_num) {
- Register reg = Register::from_code(reg_num);
- if (reg.IsAllocatable()) {
+ if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
+ reg_num)) {
+ Register reg = Register::from_code(reg_num);
if (!reg.is(esp) && !reg.is(ebp) && !reg.is(destination_reg)) {
__ push(reg);
param_offset += kPointerSize;
@@ -92,8 +93,9 @@
// Make sure no registers have been unexpectedly clobbered
for (--reg_num; reg_num >= 0; --reg_num) {
- Register reg = Register::from_code(reg_num);
- if (reg.IsAllocatable()) {
+ if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
+ reg_num)) {
+ Register reg = Register::from_code(reg_num);
if (!reg.is(esp) && !reg.is(ebp) && !reg.is(destination_reg)) {
__ cmp(reg, MemOperand(esp, 0));
__ Assert(equal, kRegisterWasClobbered);
diff --git a/test/cctest/test-code-stubs-mips.cc b/test/cctest/test-code-stubs-mips.cc
index ce577da..149a174 100644
--- a/test/cctest/test-code-stubs-mips.cc
+++ b/test/cctest/test-code-stubs-mips.cc
@@ -82,8 +82,9 @@
int source_reg_offset = kDoubleSize;
int reg_num = 2;
for (; reg_num < Register::kNumRegisters; ++reg_num) {
- Register reg = Register::from_code(reg_num);
- if (reg.IsAllocatable()) {
+ if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
+ reg_num)) {
+ Register reg = Register::from_code(reg_num);
if (!reg.is(destination_reg)) {
__ push(reg);
source_reg_offset += kPointerSize;
@@ -111,8 +112,9 @@
// Make sure no registers have been unexpectedly clobbered
for (--reg_num; reg_num >= 2; --reg_num) {
- Register reg = Register::from_code(reg_num);
- if (reg.IsAllocatable()) {
+ if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
+ reg_num)) {
+ Register reg = Register::from_code(reg_num);
if (!reg.is(destination_reg)) {
__ lw(at, MemOperand(sp, 0));
__ Assert(eq, kRegisterWasClobbered, reg, Operand(at));
diff --git a/test/cctest/test-code-stubs-mips64.cc b/test/cctest/test-code-stubs-mips64.cc
index 97f57b9..bef2171 100644
--- a/test/cctest/test-code-stubs-mips64.cc
+++ b/test/cctest/test-code-stubs-mips64.cc
@@ -81,8 +81,7 @@
// Save registers make sure they don't get clobbered.
int source_reg_offset = kDoubleSize;
int reg_num = 2;
- const RegisterConfiguration* config =
- RegisterConfiguration::ArchDefault(RegisterConfiguration::CRANKSHAFT);
+ const RegisterConfiguration* config = RegisterConfiguration::Crankshaft();
for (; reg_num < config->num_allocatable_general_registers(); ++reg_num) {
Register reg = Register::from_code(reg_num);
if (!reg.is(destination_reg)) {
diff --git a/test/cctest/test-code-stubs-x64.cc b/test/cctest/test-code-stubs-x64.cc
index 786da54..b9eddd6 100644
--- a/test/cctest/test-code-stubs-x64.cc
+++ b/test/cctest/test-code-stubs-x64.cc
@@ -64,9 +64,7 @@
__ pushq(rsi);
__ pushq(rdi);
-
- const RegisterConfiguration* config =
- RegisterConfiguration::ArchDefault(RegisterConfiguration::CRANKSHAFT);
+ const RegisterConfiguration* config = RegisterConfiguration::Crankshaft();
if (!source_reg.is(rsp)) {
// The argument we pass to the stub is not a heap number, but instead
// stack-allocated and offset-wise made to look like a heap number for
diff --git a/test/cctest/test-code-stubs-x87.cc b/test/cctest/test-code-stubs-x87.cc
index efc39e9..5a420b1 100644
--- a/test/cctest/test-code-stubs-x87.cc
+++ b/test/cctest/test-code-stubs-x87.cc
@@ -72,8 +72,9 @@
// Save registers make sure they don't get clobbered.
int reg_num = 0;
for (; reg_num < Register::kNumRegisters; ++reg_num) {
- Register reg = Register::from_code(reg_num);
- if (reg.IsAllocatable()) {
+ if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
+ reg_num)) {
+ Register reg = Register::from_code(reg_num);
if (!reg.is(esp) && !reg.is(ebp) && !reg.is(destination_reg)) {
__ push(reg);
param_offset += kPointerSize;
@@ -92,8 +93,9 @@
// Make sure no registers have been unexpectedly clobbered
for (--reg_num; reg_num >= 0; --reg_num) {
- Register reg = Register::from_code(reg_num);
- if (reg.IsAllocatable()) {
+ if (RegisterConfiguration::Crankshaft()->IsAllocatableGeneralCode(
+ reg_num)) {
+ Register reg = Register::from_code(reg_num);
if (!reg.is(esp) && !reg.is(ebp) && !reg.is(destination_reg)) {
__ cmp(reg, MemOperand(esp, 0));
__ Assert(equal, kRegisterWasClobbered);
diff --git a/test/cctest/test-compiler.cc b/test/cctest/test-compiler.cc
index 18f0009..28cdda7 100644
--- a/test/cctest/test-compiler.cc
+++ b/test/cctest/test-compiler.cc
@@ -32,6 +32,7 @@
#include "src/compiler.h"
#include "src/disasm.h"
+#include "src/interpreter/interpreter.h"
#include "src/parsing/parser.h"
#include "test/cctest/cctest.h"
@@ -305,7 +306,7 @@
// We shouldn't have deoptimization support. We want to recompile and
// verify that our feedback vector preserves information.
CHECK(!f->shared()->has_deoptimization_support());
- Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
+ Handle<TypeFeedbackVector> feedback_vector(f->feedback_vector());
// Verify that we gathered feedback.
CHECK(!feedback_vector->is_empty());
@@ -320,7 +321,7 @@
// of the full code.
CHECK(f->IsOptimized());
CHECK(f->shared()->has_deoptimization_support());
- object = f->shared()->feedback_vector()->Get(slot_for_a);
+ object = f->feedback_vector()->Get(slot_for_a);
CHECK(object->IsWeakCell() &&
WeakCell::cast(object)->value()->IsJSFunction());
}
@@ -355,13 +356,13 @@
// If we are compiling lazily then it should not be compiled, and so no
// feedback vector allocated yet.
CHECK(!f->shared()->is_compiled());
- CHECK(f->shared()->feedback_vector()->is_empty());
+ CHECK(f->feedback_vector()->is_empty());
CompileRun("morphing_call();");
// Now a feedback vector is allocated.
CHECK(f->shared()->is_compiled());
- CHECK(!f->shared()->feedback_vector()->is_empty());
+ CHECK(!f->feedback_vector()->is_empty());
}
// Test that optimized code for different closures is actually shared.
@@ -757,3 +758,45 @@
CheckCodeForUnsafeLiteral(GetJSFunction(context->Global(), "f"));
}
#endif
+
+static void IsBaselineCompiled(
+ const v8::FunctionCallbackInfo<v8::Value>& args) {
+ Handle<Object> object = v8::Utils::OpenHandle(*args[0]);
+ Handle<JSFunction> function = Handle<JSFunction>::cast(object);
+ bool is_baseline = function->shared()->code()->kind() == Code::FUNCTION;
+ return args.GetReturnValue().Set(is_baseline);
+}
+
+static void InstallIsBaselineCompiledHelper(v8::Isolate* isolate) {
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+ v8::Local<v8::FunctionTemplate> t =
+ v8::FunctionTemplate::New(isolate, IsBaselineCompiled);
+ CHECK(context->Global()
+ ->Set(context, v8_str("IsBaselineCompiled"),
+ t->GetFunction(context).ToLocalChecked())
+ .FromJust());
+}
+
+TEST(IgnitionBaselineOnReturn) {
+ FLAG_allow_natives_syntax = true;
+ FLAG_always_opt = false;
+ CcTest::InitializeVM();
+ FLAG_ignition = true;
+ reinterpret_cast<i::Isolate*>(CcTest::isolate())->interpreter()->Initialize();
+ v8::HandleScope scope(CcTest::isolate());
+ InstallIsBaselineCompiledHelper(CcTest::isolate());
+
+ CompileRun(
+ "var is_baseline_in_function, is_baseline_after_return;\n"
+ "var return_val;\n"
+ "function f() {\n"
+ " %CompileBaseline(f);\n"
+ " is_baseline_in_function = IsBaselineCompiled(f);\n"
+ " return 1234;\n"
+ "};\n"
+ "return_val = f();\n"
+ "is_baseline_after_return = IsBaselineCompiled(f);\n");
+ CHECK_EQ(false, GetGlobalProperty("is_baseline_in_function")->BooleanValue());
+ CHECK_EQ(true, GetGlobalProperty("is_baseline_after_return")->BooleanValue());
+ CHECK_EQ(1234.0, GetGlobalProperty("return_val")->Number());
+}
diff --git a/test/cctest/test-cpu-profiler.cc b/test/cctest/test-cpu-profiler.cc
index e4eceec..3bdf8ad 100644
--- a/test/cctest/test-cpu-profiler.cc
+++ b/test/cctest/test-cpu-profiler.cc
@@ -31,12 +31,13 @@
#include "include/v8-profiler.h"
#include "src/base/platform/platform.h"
-#include "src/base/smart-pointers.h"
#include "src/deoptimizer.h"
#include "src/profiler/cpu-profiler-inl.h"
+#include "src/profiler/profiler-listener.h"
#include "src/utils.h"
#include "test/cctest/cctest.h"
#include "test/cctest/profiler-extension.h"
+
using i::CodeEntry;
using i::CpuProfile;
using i::CpuProfiler;
@@ -45,10 +46,9 @@
using i::ProfileGenerator;
using i::ProfileNode;
using i::ProfilerEventsProcessor;
+using i::ProfilerListener;
using i::ScopedVector;
using i::Vector;
-using v8::base::SmartPointer;
-
// Helper methods
static v8::Local<v8::Function> GetFunction(v8::Local<v8::Context> env,
@@ -57,30 +57,26 @@
env->Global()->Get(env, v8_str(name)).ToLocalChecked());
}
-
static size_t offset(const char* src, const char* substring) {
const char* it = strstr(src, substring);
CHECK(it);
return static_cast<size_t>(it - src);
}
-
static const char* reason(const i::Deoptimizer::DeoptReason reason) {
return i::Deoptimizer::GetDeoptReason(reason);
}
-
TEST(StartStop) {
- i::Isolate* isolate = CcTest::i_isolate();
- CpuProfilesCollection profiles(isolate->heap());
+ CpuProfilesCollection profiles(CcTest::i_isolate());
ProfileGenerator generator(&profiles);
- SmartPointer<ProfilerEventsProcessor> processor(new ProfilerEventsProcessor(
- &generator, NULL, v8::base::TimeDelta::FromMicroseconds(100)));
+ std::unique_ptr<ProfilerEventsProcessor> processor(
+ new ProfilerEventsProcessor(&generator, nullptr,
+ v8::base::TimeDelta::FromMicroseconds(100)));
processor->Start();
processor->StopSynchronously();
}
-
static void EnqueueTickSampleEvent(ProfilerEventsProcessor* proc,
i::Address frame1,
i::Address frame2 = NULL,
@@ -157,46 +153,55 @@
i::AbstractCode* args3_code = CreateCode(&env);
i::AbstractCode* args4_code = CreateCode(&env);
- CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate->heap());
+ CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
+ ProfileGenerator* generator = new ProfileGenerator(profiles);
+ ProfilerEventsProcessor* processor = new ProfilerEventsProcessor(
+ generator, nullptr, v8::base::TimeDelta::FromMicroseconds(100));
+ CpuProfiler profiler(isolate, profiles, generator, processor);
profiles->StartProfiling("", false);
- ProfileGenerator generator(profiles);
- SmartPointer<ProfilerEventsProcessor> processor(new ProfilerEventsProcessor(
- &generator, NULL, v8::base::TimeDelta::FromMicroseconds(100)));
processor->Start();
- CpuProfiler profiler(isolate, profiles, &generator, processor.get());
+ ProfilerListener profiler_listener(isolate);
+ isolate->code_event_dispatcher()->AddListener(&profiler_listener);
+ profiler_listener.AddObserver(&profiler);
// Enqueue code creation events.
const char* aaa_str = "aaa";
i::Handle<i::String> aaa_name = factory->NewStringFromAsciiChecked(aaa_str);
- profiler.CodeCreateEvent(i::Logger::FUNCTION_TAG, aaa_code, *aaa_name);
- profiler.CodeCreateEvent(i::Logger::BUILTIN_TAG, comment_code, "comment");
- profiler.CodeCreateEvent(i::Logger::STUB_TAG, args5_code, 5);
- profiler.CodeCreateEvent(i::Logger::BUILTIN_TAG, comment2_code, "comment2");
- profiler.CodeMoveEvent(comment2_code, moved_code->address());
- profiler.CodeCreateEvent(i::Logger::STUB_TAG, args3_code, 3);
- profiler.CodeCreateEvent(i::Logger::STUB_TAG, args4_code, 4);
+ profiler_listener.CodeCreateEvent(i::Logger::FUNCTION_TAG, aaa_code,
+ *aaa_name);
+ profiler_listener.CodeCreateEvent(i::Logger::BUILTIN_TAG, comment_code,
+ "comment");
+ profiler_listener.CodeCreateEvent(i::Logger::STUB_TAG, args5_code, 5);
+ profiler_listener.CodeCreateEvent(i::Logger::BUILTIN_TAG, comment2_code,
+ "comment2");
+ profiler_listener.CodeMoveEvent(comment2_code, moved_code->address());
+ profiler_listener.CodeCreateEvent(i::Logger::STUB_TAG, args3_code, 3);
+ profiler_listener.CodeCreateEvent(i::Logger::STUB_TAG, args4_code, 4);
// Enqueue a tick event to enable code events processing.
- EnqueueTickSampleEvent(processor.get(), aaa_code->address());
+ EnqueueTickSampleEvent(processor, aaa_code->address());
+ profiler_listener.RemoveObserver(&profiler);
+ isolate->code_event_dispatcher()->RemoveListener(&profiler_listener);
processor->StopSynchronously();
// Check the state of profile generator.
- CodeEntry* aaa = generator.code_map()->FindEntry(aaa_code->address());
+ CodeEntry* aaa = generator->code_map()->FindEntry(aaa_code->address());
CHECK(aaa);
CHECK_EQ(0, strcmp(aaa_str, aaa->name()));
- CodeEntry* comment = generator.code_map()->FindEntry(comment_code->address());
+ CodeEntry* comment =
+ generator->code_map()->FindEntry(comment_code->address());
CHECK(comment);
CHECK_EQ(0, strcmp("comment", comment->name()));
- CodeEntry* args5 = generator.code_map()->FindEntry(args5_code->address());
+ CodeEntry* args5 = generator->code_map()->FindEntry(args5_code->address());
CHECK(args5);
CHECK_EQ(0, strcmp("5", args5->name()));
- CHECK(!generator.code_map()->FindEntry(comment2_code->address()));
+ CHECK(!generator->code_map()->FindEntry(comment2_code->address()));
- CodeEntry* comment2 = generator.code_map()->FindEntry(moved_code->address());
+ CodeEntry* comment2 = generator->code_map()->FindEntry(moved_code->address());
CHECK(comment2);
CHECK_EQ(0, strcmp("comment2", comment2->name()));
}
@@ -216,29 +221,32 @@
i::AbstractCode* frame2_code = CreateCode(&env);
i::AbstractCode* frame3_code = CreateCode(&env);
- CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate->heap());
+ CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
+ ProfileGenerator* generator = new ProfileGenerator(profiles);
+ ProfilerEventsProcessor* processor = new ProfilerEventsProcessor(
+ generator, nullptr, v8::base::TimeDelta::FromMicroseconds(100));
+ CpuProfiler profiler(isolate, profiles, generator, processor);
profiles->StartProfiling("", false);
- ProfileGenerator generator(profiles);
- SmartPointer<ProfilerEventsProcessor> processor(new ProfilerEventsProcessor(
- &generator, NULL, v8::base::TimeDelta::FromMicroseconds(100)));
processor->Start();
- CpuProfiler profiler(isolate, profiles, &generator, processor.get());
+ ProfilerListener profiler_listener(isolate);
+ isolate->code_event_dispatcher()->AddListener(&profiler_listener);
+ profiler_listener.AddObserver(&profiler);
- profiler.CodeCreateEvent(i::Logger::BUILTIN_TAG, frame1_code, "bbb");
- profiler.CodeCreateEvent(i::Logger::STUB_TAG, frame2_code, 5);
- profiler.CodeCreateEvent(i::Logger::BUILTIN_TAG, frame3_code, "ddd");
+ profiler_listener.CodeCreateEvent(i::Logger::BUILTIN_TAG, frame1_code, "bbb");
+ profiler_listener.CodeCreateEvent(i::Logger::STUB_TAG, frame2_code, 5);
+ profiler_listener.CodeCreateEvent(i::Logger::BUILTIN_TAG, frame3_code, "ddd");
- EnqueueTickSampleEvent(processor.get(), frame1_code->instruction_start());
+ EnqueueTickSampleEvent(processor, frame1_code->instruction_start());
EnqueueTickSampleEvent(
- processor.get(),
+ processor,
frame2_code->instruction_start() + frame2_code->ExecutableSize() / 2,
frame1_code->instruction_start() + frame2_code->ExecutableSize() / 2);
- EnqueueTickSampleEvent(
- processor.get(),
- frame3_code->instruction_end() - 1,
- frame2_code->instruction_end() - 1,
- frame1_code->instruction_end() - 1);
+ EnqueueTickSampleEvent(processor, frame3_code->instruction_end() - 1,
+ frame2_code->instruction_end() - 1,
+ frame1_code->instruction_end() - 1);
+ profiler_listener.RemoveObserver(&profiler);
+ isolate->code_event_dispatcher()->RemoveListener(&profiler_listener);
processor->StopSynchronously();
CpuProfile* profile = profiles->StopProfiling("");
CHECK(profile);
@@ -259,6 +267,8 @@
const i::List<ProfileNode*>* top_down_ddd_children =
top_down_stub_children->last()->children();
CHECK_EQ(0, top_down_ddd_children->length());
+
+ isolate->code_event_dispatcher()->RemoveListener(&profiler_listener);
}
// http://crbug/51594
@@ -283,15 +293,18 @@
i::AbstractCode* code = CreateCode(&env);
- CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate->heap());
+ CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
+ ProfileGenerator* generator = new ProfileGenerator(profiles);
+ ProfilerEventsProcessor* processor = new ProfilerEventsProcessor(
+ generator, nullptr, v8::base::TimeDelta::FromMicroseconds(100));
+ CpuProfiler profiler(isolate, profiles, generator, processor);
profiles->StartProfiling("", false);
- ProfileGenerator generator(profiles);
- SmartPointer<ProfilerEventsProcessor> processor(new ProfilerEventsProcessor(
- &generator, NULL, v8::base::TimeDelta::FromMicroseconds(100)));
processor->Start();
- CpuProfiler profiler(isolate, profiles, &generator, processor.get());
+ ProfilerListener profiler_listener(isolate);
+ isolate->code_event_dispatcher()->AddListener(&profiler_listener);
+ profiler_listener.AddObserver(&profiler);
- profiler.CodeCreateEvent(i::Logger::BUILTIN_TAG, code, "bbb");
+ profiler_listener.CodeCreateEvent(i::Logger::BUILTIN_TAG, code, "bbb");
i::TickSample* sample = processor->StartTickSample();
sample->pc = code->address();
@@ -302,6 +315,8 @@
}
processor->FinishTickSample();
+ profiler_listener.RemoveObserver(&profiler);
+ isolate->code_event_dispatcher()->RemoveListener(&profiler_listener);
processor->StopSynchronously();
CpuProfile* profile = profiles->StopProfiling("");
CHECK(profile);
@@ -422,7 +437,7 @@
cpu_profiler->SetSamplingInterval(100);
cpu_profiler->StartProfiling(profile_name, collect_samples);
- i::Sampler* sampler =
+ v8::sampler::Sampler* sampler =
reinterpret_cast<i::Isolate*>(env->GetIsolate())->logger()->sampler();
sampler->StartCountingSamples();
do {
@@ -1021,31 +1036,36 @@
i::Address code_address = code->instruction_start();
CHECK(code_address);
- CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate->heap());
+ CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
+ ProfileGenerator* generator = new ProfileGenerator(profiles);
+ ProfilerEventsProcessor* processor = new ProfilerEventsProcessor(
+ generator, nullptr, v8::base::TimeDelta::FromMicroseconds(100));
+ CpuProfiler profiler(isolate, profiles, generator, processor);
profiles->StartProfiling("", false);
- ProfileGenerator generator(profiles);
- SmartPointer<ProfilerEventsProcessor> processor(new ProfilerEventsProcessor(
- &generator, NULL, v8::base::TimeDelta::FromMicroseconds(100)));
processor->Start();
- CpuProfiler profiler(isolate, profiles, &generator, processor.get());
+ ProfilerListener profiler_listener(isolate);
+ isolate->code_event_dispatcher()->AddListener(&profiler_listener);
+ profiler_listener.AddObserver(&profiler);
// Enqueue code creation events.
i::Handle<i::String> str = factory->NewStringFromAsciiChecked(func_name);
int line = 1;
int column = 1;
- profiler.CodeCreateEvent(i::Logger::FUNCTION_TAG, code, func->shared(), *str,
- line, column);
+ profiler_listener.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);
+ EnqueueTickSampleEvent(processor, code_address);
+ profiler_listener.RemoveObserver(&profiler);
+ isolate->code_event_dispatcher()->RemoveListener(&profiler_listener);
processor->StopSynchronously();
CpuProfile* profile = profiles->StopProfiling("");
CHECK(profile);
// Check the state of profile generator.
- CodeEntry* func_entry = generator.code_map()->FindEntry(code_address);
+ CodeEntry* func_entry = generator->code_map()->FindEntry(code_address);
CHECK(func_entry);
CHECK_EQ(0, strcmp(func_name, func_entry->name()));
const i::JITLineInfoTable* line_info = func_entry->line_info();
@@ -1131,8 +1151,8 @@
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
GetChild(env.local(), start_node, "bar");
- const v8::CpuProfileNode* unresolved_node = FindChild(
- env.local(), root, i::ProfileGenerator::kUnresolvedFunctionName);
+ const v8::CpuProfileNode* unresolved_node =
+ FindChild(env.local(), root, i::CodeEntry::kUnresolvedFunctionName);
CHECK(!unresolved_node || GetChild(env.local(), unresolved_node, "call"));
profile->Delete();
@@ -1187,8 +1207,8 @@
GetChild(env.local(), start_node, "test");
GetChild(env.local(), test_node, "bar");
- const v8::CpuProfileNode* unresolved_node = FindChild(
- env.local(), start_node, ProfileGenerator::kUnresolvedFunctionName);
+ const v8::CpuProfileNode* unresolved_node =
+ FindChild(env.local(), start_node, CodeEntry::kUnresolvedFunctionName);
CHECK(!unresolved_node || GetChild(env.local(), unresolved_node, "apply"));
profile->Delete();
@@ -1595,12 +1615,12 @@
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
const v8::CpuProfileNode* program_node =
- GetChild(env.local(), root, ProfileGenerator::kProgramEntryName);
+ GetChild(env.local(), root, CodeEntry::kProgramEntryName);
CHECK_EQ(0, program_node->GetChildrenCount());
CHECK_GE(program_node->GetHitCount(), 2u);
const v8::CpuProfileNode* idle_node =
- GetChild(env.local(), root, ProfileGenerator::kIdleEntryName);
+ GetChild(env.local(), root, CodeEntry::kIdleEntryName);
CHECK_EQ(0, idle_node->GetChildrenCount());
CHECK_GE(idle_node->GetHitCount(), 3u);
diff --git a/test/cctest/test-date.cc b/test/cctest/test-date.cc
index 67b9501..a745949 100644
--- a/test/cctest/test-date.cc
+++ b/test/cctest/test-date.cc
@@ -166,3 +166,52 @@
CheckDST(august_20 + 2 * 3600 - 1000);
CheckDST(august_20);
}
+
+namespace {
+int legacy_parse_count = 0;
+void DateParseLegacyCounterCallback(v8::Isolate* isolate,
+ v8::Isolate::UseCounterFeature feature) {
+ if (feature == v8::Isolate::kLegacyDateParser) legacy_parse_count++;
+}
+} // anonymous namespace
+
+TEST(DateParseLegacyUseCounter) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ LocalContext context;
+ CcTest::isolate()->SetUseCounterCallback(DateParseLegacyCounterCallback);
+ CHECK_EQ(0, legacy_parse_count);
+ CompileRun("Date.parse('2015-02-31')");
+ CHECK_EQ(0, legacy_parse_count);
+ CompileRun("Date.parse('2015-02-31T11:22:33.444Z01:23')");
+ CHECK_EQ(0, legacy_parse_count);
+ CompileRun("Date.parse('2015-02-31T11:22:33.444')");
+ CHECK_EQ(0, legacy_parse_count);
+ CompileRun("Date.parse('2000 01 01')");
+ CHECK_EQ(1, legacy_parse_count);
+ CompileRun("Date.parse('2015-02-31T11:22:33.444 ')");
+ CHECK_EQ(1, legacy_parse_count);
+}
+
+#ifdef V8_I18N_SUPPORT
+TEST(DateCacheVersion) {
+ FLAG_allow_natives_syntax = true;
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+ v8::Local<v8::Number> date_cache_version =
+ v8::Local<v8::Number>::Cast(CompileRun("%DateCacheVersion()"));
+
+ CHECK(date_cache_version->IsNumber());
+ CHECK_EQ(0.0, date_cache_version->NumberValue(context).FromMaybe(-1.0));
+
+ v8::Date::DateTimeConfigurationChangeNotification(isolate);
+
+ date_cache_version =
+ v8::Local<v8::Number>::Cast(CompileRun("%DateCacheVersion()"));
+ CHECK(date_cache_version->IsNumber());
+ CHECK_EQ(1.0, date_cache_version->NumberValue(context).FromMaybe(-1.0));
+}
+#endif // V8_I18N_SUPPORT
diff --git a/test/cctest/test-debug.cc b/test/cctest/test-debug.cc
index 440c6f1..3ed6ec8 100644
--- a/test/cctest/test-debug.cc
+++ b/test/cctest/test-debug.cc
@@ -6081,53 +6081,48 @@
::v8::internal::EmbeddedVector<uint16_t, 1> empty_;
};
-
-TEST(DebugGetLoadedScripts) {
+TEST(DebugScriptLineEndsAreAscending) {
DebugLocalContext env;
- v8::HandleScope scope(env->GetIsolate());
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope scope(isolate);
env.ExposeDebug();
- v8::Local<v8::Context> context = env.context();
- EmptyExternalStringResource source_ext_str;
- v8::Local<v8::String> source =
- v8::String::NewExternalTwoByte(env->GetIsolate(), &source_ext_str)
- .ToLocalChecked();
- CHECK(v8::Script::Compile(context, source).IsEmpty());
- Handle<i::ExternalTwoByteString> i_source(
- i::ExternalTwoByteString::cast(*v8::Utils::OpenHandle(*source)));
- // This situation can happen if source was an external string disposed
- // by its owner.
- i_source->set_resource(0);
+ // Compile a test script.
+ v8::Local<v8::String> script = v8_str(isolate,
+ "function f() {\n"
+ " debugger;\n"
+ "}\n");
- bool allow_natives_syntax = i::FLAG_allow_natives_syntax;
- i::FLAG_allow_natives_syntax = true;
- EnableDebugger(env->GetIsolate());
- v8::MaybeLocal<v8::Value> result =
- CompileRun(env.context(),
- "var scripts = %DebugGetLoadedScripts();"
- "var count = scripts.length;"
- "for (var i = 0; i < count; ++i) {"
- " var lines = scripts[i].lineCount();"
- " if (lines < 1) throw 'lineCount';"
- " var last = -1;"
- " for (var j = 0; j < lines; ++j) {"
- " var end = scripts[i].lineEnd(j);"
- " if (last >= end) throw 'lineEnd';"
- " last = end;"
- " }"
- "}");
- CHECK(!result.IsEmpty());
- DisableDebugger(env->GetIsolate());
- // Must not crash while accessing line_ends.
- i::FLAG_allow_natives_syntax = allow_natives_syntax;
+ v8::ScriptOrigin origin1 = v8::ScriptOrigin(v8_str(isolate, "name"));
+ v8::Local<v8::Script> script1 =
+ v8::Script::Compile(env.context(), script, &origin1).ToLocalChecked();
+ USE(script1);
- // Some scripts are retrieved - at least the number of native scripts.
- CHECK_GT(env->Global()
- ->Get(context, v8_str(env->GetIsolate(), "count"))
- .ToLocalChecked()
- ->Int32Value(context)
- .FromJust(),
- 8);
+ Handle<v8::internal::FixedArray> instances;
+ {
+ v8::internal::Debug* debug = CcTest::i_isolate()->debug();
+ v8::internal::DebugScope debug_scope(debug);
+ CHECK(!debug_scope.failed());
+ instances = debug->GetLoadedScripts();
+ }
+
+ CHECK_GT(instances->length(), 0);
+ for (int i = 0; i < instances->length(); i++) {
+ Handle<v8::internal::Script> script = Handle<v8::internal::Script>(
+ v8::internal::Script::cast(instances->get(i)));
+
+ v8::internal::Script::InitLineEnds(script);
+ v8::internal::FixedArray* ends =
+ v8::internal::FixedArray::cast(script->line_ends());
+ CHECK_GT(ends->length(), 0);
+
+ int prev_end = -1;
+ for (int j = 0; j < ends->length(); j++) {
+ const int curr_end = v8::internal::Smi::cast(ends->get(j))->value();
+ CHECK_GT(curr_end, prev_end);
+ prev_end = curr_end;
+ }
+ }
}
@@ -7185,6 +7180,40 @@
CHECK(context.IsEmpty());
}
+static void DebugEventCheckContext(
+ const v8::Debug::EventDetails& event_details) {
+ if (event_details.GetEvent() == v8::Break) {
+ v8::Isolate* isolate = event_details.GetIsolate();
+ CHECK(v8::Debug::GetDebuggedContext(isolate)
+ .ToLocalChecked()
+ ->Global()
+ ->Equals(isolate->GetCurrentContext(),
+ event_details.GetEventContext()->Global())
+ .FromJust());
+ }
+}
+
+static void CheckContext(const v8::FunctionCallbackInfo<v8::Value>& args) {
+ CHECK(v8::Debug::GetDebuggedContext(args.GetIsolate()).IsEmpty());
+}
+
+TEST(DebuggedContext) {
+ DebugLocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+
+ v8::Debug::SetDebugEventListener(isolate, DebugEventCheckContext);
+
+ v8::Local<v8::Function> foo =
+ CompileFunction(&env, "function foo(){bar=0;}", "foo");
+
+ SetBreakPoint(foo, 0);
+ foo->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
+
+ v8::Local<v8::Function> fun = v8::FunctionTemplate::New(isolate, CheckContext)
+ ->GetFunction(env.context())
+ .ToLocalChecked();
+ fun->Call(env.context(), env->Global(), 0, nullptr).ToLocalChecked();
+}
static v8::Local<v8::Value> expected_callback_data;
static void DebugEventContextChecker(const v8::Debug::EventDetails& details) {
diff --git a/test/cctest/test-dictionary.cc b/test/cctest/test-dictionary.cc
index cc4a753..28adc7b 100644
--- a/test/cctest/test-dictionary.cc
+++ b/test/cctest/test-dictionary.cc
@@ -35,7 +35,7 @@
#include "src/global-handles.h"
#include "src/macro-assembler.h"
#include "src/objects.h"
-#include "test/cctest/heap/utils-inl.h"
+#include "test/cctest/heap/heap-utils.h"
using namespace v8::internal;
@@ -89,7 +89,7 @@
// code should not be found.
for (int i = 0; i < 100; i++) {
Handle<JSReceiver> key = factory->NewJSArray(7);
- CHECK(JSReceiver::GetOrCreateIdentityHash(key)->IsSmi());
+ CHECK(JSReceiver::GetOrCreateIdentityHash(isolate, key)->IsSmi());
CHECK_EQ(table->FindEntry(key), HashMap::kNotFound);
CHECK_EQ(table->Lookup(key), CcTest::heap()->the_hole_value());
CHECK(JSReceiver::GetIdentityHash(isolate, key)->IsSmi());
@@ -100,8 +100,8 @@
for (int i = 0; i < 100; i++) {
Handle<JSReceiver> key = factory->NewJSArray(7);
CHECK_EQ(table->Lookup(key), CcTest::heap()->the_hole_value());
- Handle<Object> identity_hash = JSReceiver::GetIdentityHash(isolate, key);
- CHECK_EQ(CcTest::heap()->undefined_value(), *identity_hash);
+ Object* identity_hash = JSReceiver::GetIdentityHash(isolate, key);
+ CHECK_EQ(CcTest::heap()->undefined_value(), identity_hash);
}
}
@@ -175,8 +175,8 @@
// Simulate a full heap so that generating an identity hash code
// in subsequent calls will request GC.
- SimulateFullSpace(CcTest::heap()->new_space());
- SimulateFullSpace(CcTest::heap()->old_space());
+ heap::SimulateFullSpace(CcTest::heap()->new_space());
+ heap::SimulateFullSpace(CcTest::heap()->old_space());
// Calling Contains() should not cause GC ever.
int gc_count = isolate->heap()->gc_count();
@@ -206,11 +206,11 @@
// Simulate a full heap so that generating an identity hash code
// in subsequent calls will request GC.
- SimulateFullSpace(CcTest::heap()->new_space());
- SimulateFullSpace(CcTest::heap()->old_space());
+ heap::SimulateFullSpace(CcTest::heap()->new_space());
+ heap::SimulateFullSpace(CcTest::heap()->old_space());
// Calling Lookup() should not cause GC ever.
- CHECK(table->Lookup(key)->IsTheHole());
+ CHECK(table->Lookup(key)->IsTheHole(isolate));
// Calling Put() should request GC by returning a failure.
int gc_count = isolate->heap()->gc_count();
diff --git a/test/cctest/test-disasm-arm.cc b/test/cctest/test-disasm-arm.cc
index 40745f9..d5f5949 100644
--- a/test/cctest/test-disasm-arm.cc
+++ b/test/cctest/test-disasm-arm.cc
@@ -1171,3 +1171,17 @@
VERIFY_RUN();
}
+
+
+TEST(LoadStoreExclusive) {
+ SET_UP();
+
+ COMPARE(ldrexb(r0, r1), "e1d10f9f ldrexb r0, [r1]");
+ COMPARE(strexb(r0, r1, r2), "e1c20f91 strexb r0, r1, [r2]");
+ COMPARE(ldrexh(r0, r1), "e1f10f9f ldrexh r0, [r1]");
+ COMPARE(strexh(r0, r1, r2), "e1e20f91 strexh r0, r1, [r2]");
+ COMPARE(ldrex(r0, r1), "e1910f9f ldrex r0, [r1]");
+ COMPARE(strex(r0, r1, r2), "e1820f91 strex r0, r1, [r2]");
+
+ VERIFY_RUN();
+}
diff --git a/test/cctest/test-disasm-arm64.cc b/test/cctest/test-disasm-arm64.cc
index beca93e..c3653bd 100644
--- a/test/cctest/test-disasm-arm64.cc
+++ b/test/cctest/test-disasm-arm64.cc
@@ -1259,6 +1259,24 @@
CLEANUP();
}
+TEST_(load_store_acquire_release) {
+ SET_UP_MASM();
+
+ COMPARE(ldar(w0, x1), "ldar w0, [x1]");
+ COMPARE(ldarb(w2, x3), "ldarb w2, [x3]");
+ COMPARE(ldarh(w4, x5), "ldarh w4, [x5]");
+ COMPARE(ldaxr(w6, x7), "ldaxr w6, [x7]");
+ COMPARE(ldaxrb(w8, x9), "ldaxrb w8, [x9]");
+ COMPARE(ldaxrh(w10, x11), "ldaxrh w10, [x11]");
+ COMPARE(stlr(w12, x13), "stlr w12, [x13]");
+ COMPARE(stlrb(w14, x15), "stlrb w14, [x15]");
+ COMPARE(stlrh(w16, x17), "stlrh w16, [x17]");
+ COMPARE(stlxr(w18, w19, x20), "stlxr w18, w19, [x20]");
+ COMPARE(stlxrb(w21, w22, x23), "stlxrb w21, w22, [x23]");
+ COMPARE(stlxrh(w24, w25, x26), "stlxrh w24, w25, [x26]");
+
+ CLEANUP();
+}
#if 0 // TODO(all): enable.
TEST_(load_literal) {
diff --git a/test/cctest/test-disasm-ia32.cc b/test/cctest/test-disasm-ia32.cc
index 3ecd7b3..5bd11bc 100644
--- a/test/cctest/test-disasm-ia32.cc
+++ b/test/cctest/test-disasm-ia32.cc
@@ -290,7 +290,7 @@
__ bind(&L2);
__ call(Operand(ebx, ecx, times_4, 10000));
__ nop();
- Handle<Code> ic(CodeFactory::LoadIC(isolate, NOT_INSIDE_TYPEOF).code());
+ Handle<Code> ic(CodeFactory::LoadIC(isolate).code());
__ call(ic, RelocInfo::CODE_TARGET);
__ nop();
__ call(FUNCTION_ADDR(DummyStaticFunction), RelocInfo::RUNTIME_ENTRY);
@@ -665,12 +665,30 @@
// xchg.
{
+ __ xchg_b(eax, Operand(eax, 8));
+ __ xchg_w(eax, Operand(ebx, 8));
__ xchg(eax, eax);
__ xchg(eax, ebx);
__ xchg(ebx, ebx);
__ xchg(ebx, Operand(esp, 12));
}
+ // cmpxchg.
+ {
+ __ cmpxchg_b(Operand(esp, 12), eax);
+ __ cmpxchg_w(Operand(ebx, ecx, times_4, 10000), eax);
+ __ cmpxchg(Operand(ebx, ecx, times_4, 10000), eax);
+ }
+
+ // lock prefix.
+ {
+ __ lock();
+ __ cmpxchg(Operand(esp, 12), ebx);
+
+ __ lock();
+ __ xchg_w(eax, Operand(ecx, 8));
+ }
+
// Nop instructions
for (int i = 0; i < 16; i++) {
__ Nop(i);
diff --git a/test/cctest/test-disasm-mips.cc b/test/cctest/test-disasm-mips.cc
index 9a7d8ae..b4f81ec 100644
--- a/test/cctest/test-disasm-mips.cc
+++ b/test/cctest/test-disasm-mips.cc
@@ -97,7 +97,6 @@
V8_Fatal(__FILE__, __LINE__, "MIPS Disassembler tests failed.\n"); \
}
-
#define COMPARE_PC_REL_COMPACT(asm_, compare_string, offset) \
{ \
int pc_offset = assm.pc_offset(); \
@@ -106,28 +105,28 @@
prev_instr_compact_branch = assm.IsPrevInstrCompactBranch(); \
if (prev_instr_compact_branch) { \
snprintf(str_with_address, sizeof(str_with_address), "%s -> %p", \
- compare_string, progcounter + 8 + (offset * 4)); \
+ compare_string, \
+ static_cast<void *>(progcounter + 8 + (offset * 4))); \
} else { \
snprintf(str_with_address, sizeof(str_with_address), "%s -> %p", \
- compare_string, progcounter + 4 + (offset * 4)); \
+ compare_string, \
+ static_cast<void *>(progcounter + 4 + (offset * 4))); \
} \
assm.asm_; \
if (!DisassembleAndCompare(progcounter, str_with_address)) failure = true; \
}
-
#define COMPARE_PC_REL(asm_, compare_string, offset) \
{ \
int pc_offset = assm.pc_offset(); \
byte *progcounter = &buffer[pc_offset]; \
char str_with_address[100]; \
snprintf(str_with_address, sizeof(str_with_address), "%s -> %p", \
- compare_string, progcounter + (offset * 4)); \
+ compare_string, static_cast<void *>(progcounter + (offset * 4))); \
assm.asm_; \
if (!DisassembleAndCompare(progcounter, str_with_address)) failure = true; \
}
-
#define COMPARE_PC_JUMP(asm_, compare_string, target) \
{ \
int pc_offset = assm.pc_offset(); \
@@ -136,14 +135,13 @@
int instr_index = (target >> 2) & kImm26Mask; \
snprintf( \
str_with_address, sizeof(str_with_address), "%s %p -> %p", \
- compare_string, reinterpret_cast<byte *>(target), \
- reinterpret_cast<byte *>(((uint32_t)(progcounter + 4) & ~0xfffffff) | \
+ compare_string, reinterpret_cast<void *>(target), \
+ reinterpret_cast<void *>(((uint32_t)(progcounter + 4) & ~0xfffffff) | \
(instr_index << 2))); \
assm.asm_; \
if (!DisassembleAndCompare(progcounter, str_with_address)) failure = true; \
}
-
#define GET_PC_REGION(pc_region) \
{ \
int pc_offset = assm.pc_offset(); \
@@ -780,6 +778,20 @@
}
if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+ COMPARE(seb(a0, a1), "7c052420 seb a0, a1");
+ COMPARE(seb(s6, s7), "7c17b420 seb s6, s7");
+ COMPARE(seb(v0, v1), "7c031420 seb v0, v1");
+
+ COMPARE(seh(a0, a1), "7c052620 seh a0, a1");
+ COMPARE(seh(s6, s7), "7c17b620 seh s6, s7");
+ COMPARE(seh(v0, v1), "7c031620 seh v0, v1");
+
+ COMPARE(wsbh(a0, a1), "7c0520a0 wsbh a0, a1");
+ COMPARE(wsbh(s6, s7), "7c17b0a0 wsbh s6, s7");
+ COMPARE(wsbh(v0, v1), "7c0310a0 wsbh v0, v1");
+ }
+
+ if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
COMPARE(ins_(a0, a1, 31, 1),
"7ca4ffc4 ins a0, a1, 31, 1");
COMPARE(ins_(s6, s7, 30, 2),
diff --git a/test/cctest/test-disasm-mips64.cc b/test/cctest/test-disasm-mips64.cc
index d8f5681..dc6f34e 100644
--- a/test/cctest/test-disasm-mips64.cc
+++ b/test/cctest/test-disasm-mips64.cc
@@ -97,7 +97,6 @@
V8_Fatal(__FILE__, __LINE__, "MIPS Disassembler tests failed.\n"); \
}
-
#define COMPARE_PC_REL_COMPACT(asm_, compare_string, offset) \
{ \
int pc_offset = assm.pc_offset(); \
@@ -106,28 +105,28 @@
prev_instr_compact_branch = assm.IsPrevInstrCompactBranch(); \
if (prev_instr_compact_branch) { \
snprintf(str_with_address, sizeof(str_with_address), "%s -> %p", \
- compare_string, progcounter + 8 + (offset * 4)); \
+ compare_string, \
+ static_cast<void *>(progcounter + 8 + (offset * 4))); \
} else { \
snprintf(str_with_address, sizeof(str_with_address), "%s -> %p", \
- compare_string, progcounter + 4 + (offset * 4)); \
+ compare_string, \
+ static_cast<void *>(progcounter + 4 + (offset * 4))); \
} \
assm.asm_; \
if (!DisassembleAndCompare(progcounter, str_with_address)) failure = true; \
}
-
#define COMPARE_PC_REL(asm_, compare_string, offset) \
{ \
int pc_offset = assm.pc_offset(); \
byte *progcounter = &buffer[pc_offset]; \
char str_with_address[100]; \
snprintf(str_with_address, sizeof(str_with_address), "%s -> %p", \
- compare_string, progcounter + (offset * 4)); \
+ compare_string, static_cast<void *>(progcounter + (offset * 4))); \
assm.asm_; \
if (!DisassembleAndCompare(progcounter, str_with_address)) failure = true; \
}
-
#define COMPARE_PC_JUMP(asm_, compare_string, target) \
{ \
int pc_offset = assm.pc_offset(); \
@@ -136,14 +135,13 @@
int instr_index = (target >> 2) & kImm26Mask; \
snprintf( \
str_with_address, sizeof(str_with_address), "%s %p -> %p", \
- compare_string, reinterpret_cast<byte *>(target), \
- reinterpret_cast<byte *>(((uint64_t)(progcounter + 1) & ~0xfffffff) | \
+ compare_string, reinterpret_cast<void *>(target), \
+ reinterpret_cast<void *>(((uint64_t)(progcounter + 1) & ~0xfffffff) | \
(instr_index << 2))); \
assm.asm_; \
if (!DisassembleAndCompare(progcounter, str_with_address)) failure = true; \
}
-
#define GET_PC_REGION(pc_region) \
{ \
int pc_offset = assm.pc_offset(); \
@@ -685,6 +683,26 @@
"70621020 clz v0, v1");
}
+ COMPARE(seb(a0, a1), "7c052420 seb a0, a1");
+ COMPARE(seb(s6, s7), "7c17b420 seb s6, s7");
+ COMPARE(seb(v0, v1), "7c031420 seb v0, v1");
+
+ COMPARE(seh(a0, a1), "7c052620 seh a0, a1");
+ COMPARE(seh(s6, s7), "7c17b620 seh s6, s7");
+ COMPARE(seh(v0, v1), "7c031620 seh v0, v1");
+
+ COMPARE(wsbh(a0, a1), "7c0520a0 wsbh a0, a1");
+ COMPARE(wsbh(s6, s7), "7c17b0a0 wsbh s6, s7");
+ COMPARE(wsbh(v0, v1), "7c0310a0 wsbh v0, v1");
+
+ COMPARE(dsbh(a0, a1), "7c0520a4 dsbh a0, a1");
+ COMPARE(dsbh(s6, s7), "7c17b0a4 dsbh s6, s7");
+ COMPARE(dsbh(v0, v1), "7c0310a4 dsbh v0, v1");
+
+ COMPARE(dshd(a0, a1), "7c052164 dshd a0, a1");
+ COMPARE(dshd(s6, s7), "7c17b164 dshd s6, s7");
+ COMPARE(dshd(v0, v1), "7c031164 dshd v0, v1");
+
COMPARE(ins_(a0, a1, 31, 1),
"7ca4ffc4 ins a0, a1, 31, 1");
COMPARE(ins_(s6, s7, 30, 2),
diff --git a/test/cctest/test-disasm-x64.cc b/test/cctest/test-disasm-x64.cc
index b855626..64d97ea 100644
--- a/test/cctest/test-disasm-x64.cc
+++ b/test/cctest/test-disasm-x64.cc
@@ -282,7 +282,7 @@
// TODO(mstarzinger): The following is protected.
// __ call(Operand(rbx, rcx, times_4, 10000));
__ nop();
- Handle<Code> ic(CodeFactory::LoadIC(isolate, NOT_INSIDE_TYPEOF).code());
+ Handle<Code> ic(CodeFactory::LoadIC(isolate).code());
__ call(ic, RelocInfo::CODE_TARGET);
__ nop();
__ nop();
@@ -458,6 +458,7 @@
__ pcmpeqd(xmm1, xmm0);
__ punpckldq(xmm1, xmm11);
+ __ punpckldq(xmm5, Operand(rdx, 4));
__ punpckhdq(xmm8, xmm15);
}
@@ -484,11 +485,46 @@
{
if (CpuFeatures::IsSupported(SSE4_1)) {
CpuFeatureScope scope(&assm, SSE4_1);
+ __ insertps(xmm5, xmm1, 123);
__ extractps(rax, xmm1, 0);
__ pextrd(rbx, xmm15, 0);
__ pextrd(r12, xmm0, 1);
__ pinsrd(xmm9, r9, 0);
- __ pinsrd(xmm5, rax, 1);
+ __ pinsrd(xmm5, Operand(rax, 4), 1);
+
+ __ cmpps(xmm5, xmm1, 1);
+ __ cmpeqps(xmm5, xmm1);
+ __ cmpltps(xmm5, xmm1);
+ __ cmpleps(xmm5, xmm1);
+ __ cmpneqps(xmm5, xmm1);
+ __ cmpnltps(xmm5, xmm1);
+ __ cmpnleps(xmm5, xmm1);
+
+ __ minps(xmm5, xmm1);
+ __ minps(xmm5, Operand(rdx, 4));
+ __ maxps(xmm5, xmm1);
+ __ maxps(xmm5, Operand(rdx, 4));
+ __ rcpps(xmm5, xmm1);
+ __ rcpps(xmm5, Operand(rdx, 4));
+ __ sqrtps(xmm5, xmm1);
+ __ sqrtps(xmm5, Operand(rdx, 4));
+ __ movups(xmm5, xmm1);
+ __ movups(xmm5, Operand(rdx, 4));
+ __ movups(Operand(rdx, 4), xmm5);
+ __ paddd(xmm5, xmm1);
+ __ paddd(xmm5, Operand(rdx, 4));
+ __ psubd(xmm5, xmm1);
+ __ psubd(xmm5, Operand(rdx, 4));
+ __ pmulld(xmm5, xmm1);
+ __ pmulld(xmm5, Operand(rdx, 4));
+ __ pmuludq(xmm5, xmm1);
+ __ pmuludq(xmm5, Operand(rdx, 4));
+ __ psrldq(xmm5, 123);
+ __ pshufd(xmm5, xmm1, 3);
+ __ cvtps2dq(xmm5, xmm1);
+ __ cvtps2dq(xmm5, Operand(rdx, 4));
+ __ cvtdq2ps(xmm5, xmm1);
+ __ cvtdq2ps(xmm5, Operand(rdx, 4));
}
}
@@ -745,12 +781,31 @@
// xchg.
{
+ __ xchgb(rax, Operand(rax, 8));
+ __ xchgw(rax, Operand(rbx, 8));
__ xchgq(rax, rax);
__ xchgq(rax, rbx);
__ xchgq(rbx, rbx);
__ xchgq(rbx, Operand(rsp, 12));
}
+ // cmpxchg.
+ {
+ __ cmpxchgb(Operand(rsp, 12), rax);
+ __ cmpxchgw(Operand(rbx, rcx, times_4, 10000), rax);
+ __ cmpxchgl(Operand(rbx, rcx, times_4, 10000), rax);
+ __ cmpxchgq(Operand(rbx, rcx, times_4, 10000), rax);
+ }
+
+ // lock prefix.
+ {
+ __ lock();
+ __ cmpxchgl(Operand(rsp, 12), rbx);
+
+ __ lock();
+ __ xchgw(rax, Operand(rcx, 8));
+ }
+
// Nop instructions
for (int i = 0; i < 16; i++) {
__ Nop(i);
diff --git a/test/cctest/test-disasm-x87.cc b/test/cctest/test-disasm-x87.cc
index 9a4c6d4..41f425d 100644
--- a/test/cctest/test-disasm-x87.cc
+++ b/test/cctest/test-disasm-x87.cc
@@ -290,7 +290,7 @@
__ bind(&L2);
__ call(Operand(ebx, ecx, times_4, 10000));
__ nop();
- Handle<Code> ic(CodeFactory::LoadIC(isolate, NOT_INSIDE_TYPEOF).code());
+ Handle<Code> ic(CodeFactory::LoadIC(isolate).code());
__ call(ic, RelocInfo::CODE_TARGET);
__ nop();
__ call(FUNCTION_ADDR(DummyStaticFunction), RelocInfo::RUNTIME_ENTRY);
@@ -395,12 +395,30 @@
// xchg.
{
+ __ xchg_b(eax, Operand(eax, 8));
+ __ xchg_w(eax, Operand(ebx, 8));
__ xchg(eax, eax);
__ xchg(eax, ebx);
__ xchg(ebx, ebx);
__ xchg(ebx, Operand(esp, 12));
}
+ // cmpxchg.
+ {
+ __ cmpxchg_b(Operand(esp, 12), eax);
+ __ cmpxchg_w(Operand(ebx, ecx, times_4, 10000), eax);
+ __ cmpxchg(Operand(ebx, ecx, times_4, 10000), eax);
+ }
+
+ // lock prefix.
+ {
+ __ lock();
+ __ cmpxchg(Operand(esp, 12), ebx);
+
+ __ lock();
+ __ xchg_w(eax, Operand(ecx, 8));
+ }
+
// Nop instructions
for (int i = 0; i < 16; i++) {
__ Nop(i);
diff --git a/test/cctest/test-eh-frame-hdr.cc b/test/cctest/test-eh-frame-hdr.cc
new file mode 100644
index 0000000..d9539c7
--- /dev/null
+++ b/test/cctest/test-eh-frame-hdr.cc
@@ -0,0 +1,100 @@
+// 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/eh-frame.h"
+#include "src/objects.h"
+#include "test/cctest/cctest.h"
+
+using namespace v8::internal;
+
+TEST(EhFrameHdr) {
+ CcTest::InitializeVM();
+ HandleScope handle_scope(CcTest::i_isolate());
+
+ // The content is not relevant in this test
+ byte buffer[10] = {0};
+ byte unwinding_info[30 + EhFrameHdr::kRecordSize] = {0};
+
+ CodeDesc code_desc;
+ code_desc.buffer = &buffer[0];
+ code_desc.buffer_size = sizeof(buffer);
+ code_desc.constant_pool_size = 0;
+ code_desc.instr_size = sizeof(buffer);
+ code_desc.reloc_size = 0;
+ code_desc.origin = nullptr;
+ code_desc.unwinding_info = &unwinding_info[0];
+ code_desc.unwinding_info_size = sizeof(unwinding_info);
+
+ Handle<Code> code = CcTest::i_isolate()->factory()->NewCode(
+ code_desc, 0, Handle<Object>::null());
+
+ EhFrameHdr eh_frame_hdr(*code);
+ CHECK_EQ(eh_frame_hdr.lut_entries_number(), 1);
+
+ //
+ // Plugging some numbers in the DSO layout shown in eh-frame.cc:
+ //
+ // | ... |
+ // +---------------+ <-- (E) --------
+ // | | ^
+ // | Instructions | 10 bytes | .text
+ // | | v
+ // +---------------+ <---------------
+ // |///////////////|
+ // |////Padding////| 6 bytes
+ // |///////////////|
+ // +---------------+ <---(D)---------
+ // | | ^
+ // | CIE | N bytes* |
+ // | | |
+ // +---------------+ <-- (C) | .eh_frame
+ // | | |
+ // | FDE | 30 - N bytes |
+ // | | v
+ // +---------------+ <-- (B) --------
+ // | version | ^
+ // +---------------+ 4 bytes |
+ // | encoding | |
+ // | specifiers | |
+ // +---------------+ <---(A) | .eh_frame_hdr
+ // | offset to | |
+ // | .eh_frame | |
+ // +---------------+ |
+ // | ... | ...
+ //
+ // (*) the size of the CIE is platform dependent.
+ //
+ CHECK_EQ(eh_frame_hdr.offset_to_eh_frame(), -(4 + 30)); // A -> D
+ CHECK_EQ(eh_frame_hdr.offset_to_procedure(), -(30 + 6 + 10)); // B -> E
+ CHECK_EQ(eh_frame_hdr.offset_to_fde(),
+ -(30 - EhFrameHdr::kCIESize)); // B -> C
+}
+
+TEST(DummyEhFrameHdr) {
+ CcTest::InitializeVM();
+ HandleScope handle_scope(CcTest::i_isolate());
+
+ byte buffer[10] = {0}; // The content is not relevant in this test
+
+ CodeDesc code_desc;
+ code_desc.buffer = &buffer[0];
+ code_desc.buffer_size = sizeof(buffer);
+ code_desc.constant_pool_size = 0;
+ code_desc.instr_size = sizeof(buffer);
+ code_desc.reloc_size = 0;
+ code_desc.origin = nullptr;
+ code_desc.unwinding_info = nullptr;
+ code_desc.unwinding_info_size = 0;
+
+ Handle<Code> code = CcTest::i_isolate()->factory()->NewCode(
+ code_desc, 0, Handle<Object>::null());
+
+ EhFrameHdr eh_frame_hdr(*code);
+ // A dummy header has an empty LUT
+ CHECK_EQ(eh_frame_hdr.lut_entries_number(), 0);
+ // These values should be irrelevant, but check that they have been zeroed.
+ CHECK_EQ(eh_frame_hdr.offset_to_eh_frame(), 0);
+ CHECK_EQ(eh_frame_hdr.offset_to_procedure(), 0);
+ CHECK_EQ(eh_frame_hdr.offset_to_fde(), 0);
+}
diff --git a/test/cctest/test-feedback-vector.cc b/test/cctest/test-feedback-vector.cc
index c06e5b9..69c60ca 100644
--- a/test/cctest/test-feedback-vector.cc
+++ b/test/cctest/test-feedback-vector.cc
@@ -208,7 +208,7 @@
Handle<JSFunction> f = GetFunction("f");
// There should be one IC.
Handle<TypeFeedbackVector> feedback_vector =
- Handle<TypeFeedbackVector>(f->shared()->feedback_vector(), isolate);
+ Handle<TypeFeedbackVector>(f->feedback_vector(), isolate);
FeedbackVectorSlot slot(0);
CallICNexus nexus(feedback_vector, slot);
CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
@@ -233,6 +233,41 @@
CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
}
+TEST(VectorCallCounts) {
+ if (i::FLAG_always_opt) return;
+ CcTest::InitializeVM();
+ LocalContext context;
+ v8::HandleScope scope(context->GetIsolate());
+ Isolate* isolate = CcTest::i_isolate();
+
+ // Make sure function f has a call that uses a type feedback slot.
+ CompileRun(
+ "function foo() { return 17; }"
+ "function f(a) { a(); } f(foo);");
+ Handle<JSFunction> f = GetFunction("f");
+ // There should be one IC.
+ Handle<TypeFeedbackVector> feedback_vector =
+ Handle<TypeFeedbackVector>(f->feedback_vector(), isolate);
+ FeedbackVectorSlot slot(0);
+ CallICNexus nexus(feedback_vector, slot);
+ CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
+
+ CompileRun("f(foo); f(foo);");
+ CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
+ CHECK_EQ(3, nexus.ExtractCallCount());
+
+ CompileRun(
+ "function Foo() {}"
+ "function f(a) { new a(); } f(Foo);");
+ f = GetFunction("f");
+ // There should be one IC.
+ feedback_vector = Handle<TypeFeedbackVector>(f->feedback_vector(), isolate);
+ FeedbackVectorSlot cslot(1);
+
+ CompileRun("f(Foo); f(Foo);");
+ CHECK(feedback_vector->Get(cslot)->IsSmi());
+ CHECK_EQ(3, Smi::cast(feedback_vector->Get(cslot))->value());
+}
TEST(VectorLoadICStates) {
if (i::FLAG_always_opt) return;
@@ -249,7 +284,7 @@
Handle<JSFunction> f = GetFunction("f");
// There should be one IC.
Handle<TypeFeedbackVector> feedback_vector =
- Handle<TypeFeedbackVector>(f->shared()->feedback_vector(), isolate);
+ Handle<TypeFeedbackVector>(f->feedback_vector(), isolate);
FeedbackVectorSlot slot(0);
LoadICNexus nexus(feedback_vector, slot);
CHECK_EQ(PREMONOMORPHIC, nexus.StateFromFeedback());
@@ -308,11 +343,11 @@
Handle<JSFunction> f = GetFunction("f");
// There should be one IC slot.
Handle<TypeFeedbackVector> feedback_vector =
- Handle<TypeFeedbackVector>(f->shared()->feedback_vector(), isolate);
+ Handle<TypeFeedbackVector>(f->feedback_vector(), isolate);
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(1, helper.slot_count());
FeedbackVectorSlot slot(0);
- LoadICNexus nexus(feedback_vector, slot);
+ LoadGlobalICNexus nexus(feedback_vector, slot);
CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
}
@@ -332,7 +367,7 @@
Handle<JSFunction> f = GetFunction("f");
// There should be one IC.
Handle<TypeFeedbackVector> feedback_vector =
- Handle<TypeFeedbackVector>(f->shared()->feedback_vector(), isolate);
+ Handle<TypeFeedbackVector>(f->feedback_vector(), isolate);
FeedbackVectorSlot slot(0);
LoadICNexus nexus(feedback_vector, slot);
CHECK_EQ(PREMONOMORPHIC, nexus.StateFromFeedback());
@@ -397,13 +432,13 @@
// There should be two LOAD_ICs, one for a and one for y at the end.
Handle<TypeFeedbackVector> feedback_vector =
- handle(f->shared()->feedback_vector(), isolate);
+ handle(f->feedback_vector(), isolate);
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(4, helper.slot_count());
CHECK_SLOT_KIND(helper, 0, FeedbackVectorSlotKind::STORE_IC);
- CHECK_SLOT_KIND(helper, 1, FeedbackVectorSlotKind::LOAD_IC);
+ CHECK_SLOT_KIND(helper, 1, FeedbackVectorSlotKind::LOAD_GLOBAL_IC);
CHECK_SLOT_KIND(helper, 2, FeedbackVectorSlotKind::STORE_IC);
- CHECK_SLOT_KIND(helper, 3, FeedbackVectorSlotKind::LOAD_IC);
+ CHECK_SLOT_KIND(helper, 3, FeedbackVectorSlotKind::LOAD_GLOBAL_IC);
}
{
@@ -416,9 +451,11 @@
Handle<JSFunction> f = GetFunction("testprop");
// There should be one LOAD_IC, for the load of a.
- Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
+ Handle<TypeFeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(2, helper.slot_count());
+ CHECK_SLOT_KIND(helper, 0, FeedbackVectorSlotKind::LOAD_GLOBAL_IC);
+ CHECK_SLOT_KIND(helper, 1, FeedbackVectorSlotKind::STORE_IC);
}
{
@@ -432,12 +469,13 @@
Handle<JSFunction> f = GetFunction("testpropfunc");
- // There should be 2 LOAD_ICs and 2 CALL_ICs.
- Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
+ // There should be 1 LOAD_GLOBAL_IC to load x (in both cases), 2 CALL_ICs
+ // to call x and a LOAD_IC to load blue.
+ Handle<TypeFeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(5, helper.slot_count());
CHECK_SLOT_KIND(helper, 0, FeedbackVectorSlotKind::CALL_IC);
- CHECK_SLOT_KIND(helper, 1, FeedbackVectorSlotKind::LOAD_IC);
+ CHECK_SLOT_KIND(helper, 1, FeedbackVectorSlotKind::LOAD_GLOBAL_IC);
CHECK_SLOT_KIND(helper, 2, FeedbackVectorSlotKind::STORE_IC);
CHECK_SLOT_KIND(helper, 3, FeedbackVectorSlotKind::CALL_IC);
CHECK_SLOT_KIND(helper, 4, FeedbackVectorSlotKind::LOAD_IC);
@@ -453,12 +491,12 @@
Handle<JSFunction> f = GetFunction("testkeyedprop");
- // There should be 1 LOAD_ICs for the load of a, and one KEYED_LOAD_IC for
- // the load of x[0] in the return statement.
- Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
+ // There should be 1 LOAD_GLOBAL_ICs for the load of a, and one
+ // KEYED_LOAD_IC for the load of x[0] in the return statement.
+ Handle<TypeFeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(3, helper.slot_count());
- CHECK_SLOT_KIND(helper, 0, FeedbackVectorSlotKind::LOAD_IC);
+ CHECK_SLOT_KIND(helper, 0, FeedbackVectorSlotKind::LOAD_GLOBAL_IC);
CHECK_SLOT_KIND(helper, 1, FeedbackVectorSlotKind::KEYED_STORE_IC);
CHECK_SLOT_KIND(helper, 2, FeedbackVectorSlotKind::KEYED_LOAD_IC);
}
@@ -473,11 +511,12 @@
Handle<JSFunction> f = GetFunction("testcompound");
- // There should be 3 LOAD_ICs, for load of a and load of x.old and x.young.
- Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
+ // There should be 1 LOAD_GLOBAL_IC for load of a and 2 LOAD_ICs, for load
+ // of x.old and x.young.
+ Handle<TypeFeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(6, helper.slot_count());
- CHECK_SLOT_KIND(helper, 0, FeedbackVectorSlotKind::LOAD_IC);
+ CHECK_SLOT_KIND(helper, 0, FeedbackVectorSlotKind::LOAD_GLOBAL_IC);
CHECK_SLOT_KIND(helper, 1, FeedbackVectorSlotKind::STORE_IC);
CHECK_SLOT_KIND(helper, 2, FeedbackVectorSlotKind::STORE_IC);
CHECK_SLOT_KIND(helper, 3, FeedbackVectorSlotKind::STORE_IC);
@@ -504,7 +543,7 @@
"f(a);");
Handle<JSFunction> f = GetFunction("f");
// There should be one IC slot.
- Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
+ Handle<TypeFeedbackVector> feedback_vector(f->feedback_vector());
FeedbackVectorHelper helper(feedback_vector);
CHECK_EQ(1, helper.slot_count());
FeedbackVectorSlot slot(0);
diff --git a/test/cctest/test-field-type-tracking.cc b/test/cctest/test-field-type-tracking.cc
index 9709f87..33a2dac 100644
--- a/test/cctest/test-field-type-tracking.cc
+++ b/test/cctest/test-field-type-tracking.cc
@@ -388,16 +388,16 @@
Handle<String> name = MakeName("prop", property_index);
- CHECK(!getter->IsNull() || !setter->IsNull());
+ CHECK(!getter->IsNull(isolate_) || !setter->IsNull(isolate_));
Factory* factory = isolate_->factory();
- if (!getter->IsNull()) {
+ if (!getter->IsNull(isolate_)) {
Handle<AccessorPair> pair = factory->NewAccessorPair();
pair->SetComponents(*getter, *factory->null_value());
AccessorConstantDescriptor new_desc(name, pair, attributes);
map = Map::CopyInsertDescriptor(map, &new_desc, INSERT_TRANSITION);
}
- if (!setter->IsNull()) {
+ if (!setter->IsNull(isolate_)) {
Handle<AccessorPair> pair = factory->NewAccessorPair();
pair->SetComponents(*getter, *setter);
AccessorConstantDescriptor new_desc(name, pair, attributes);
@@ -486,7 +486,7 @@
Handle<JSObject> obj = factory->NewJSObjectFromMap(map);
JSObject::MigrateToMap(obj, prepared_map);
FieldIndex index = FieldIndex::ForDescriptor(*prepared_map, 0);
- CHECK(obj->RawFastPropertyAt(index)->IsUninitialized());
+ CHECK(obj->RawFastPropertyAt(index)->IsUninitialized(isolate));
#ifdef VERIFY_HEAP
obj->ObjectVerify();
#endif
@@ -644,7 +644,7 @@
Map* tmp = *new_map;
while (true) {
Object* back = tmp->GetBackPointer();
- if (back->IsUndefined()) break;
+ if (back->IsUndefined(isolate)) break;
tmp = Map::cast(back);
CHECK(!tmp->is_stable());
}
@@ -1242,7 +1242,7 @@
CHECK(!map->is_deprecated());
CHECK_NE(*map, *new_map);
- CHECK(new_map->GetBackPointer()->IsUndefined());
+ CHECK(new_map->GetBackPointer()->IsUndefined(map->GetIsolate()));
for (int i = 0; i < kPropCount; i++) {
expectations.GeneralizeRepresentation(i);
}
@@ -1873,7 +1873,7 @@
// Try to update |map|, since there is no place for propX transition at |map2|
// |map| should become "copy-generalized".
Handle<Map> updated_map = Map::Update(map);
- CHECK(updated_map->GetBackPointer()->IsUndefined());
+ CHECK(updated_map->GetBackPointer()->IsUndefined(isolate));
for (int i = 0; i < kPropCount; i++) {
expectations.SetDataField(i, Representation::Tagged(), any_type);
@@ -1973,10 +1973,10 @@
for (int i = 0; i < kPropCount; i++) {
expectations2.GeneralizeRepresentation(i);
}
- CHECK(new_map2->GetBackPointer()->IsUndefined());
+ CHECK(new_map2->GetBackPointer()->IsUndefined(isolate));
CHECK(expectations2.Check(*new_map2));
} else {
- CHECK(!new_map2->GetBackPointer()->IsUndefined());
+ CHECK(!new_map2->GetBackPointer()->IsUndefined(isolate));
CHECK(expectations2.Check(*new_map2));
}
}
diff --git a/test/cctest/test-hashmap.cc b/test/cctest/test-hashmap.cc
index b45d6c7..2d423b4 100644
--- a/test/cctest/test-hashmap.cc
+++ b/test/cctest/test-hashmap.cc
@@ -30,7 +30,7 @@
#include "src/v8.h"
#include "test/cctest/cctest.h"
-#include "src/hashmap.h"
+#include "src/base/hashmap.h"
using namespace v8::internal;
@@ -48,7 +48,7 @@
void Insert(int x) {
CHECK_NE(0, x); // 0 corresponds to (void*)NULL - illegal key value
- HashMap::Entry* p =
+ v8::base::HashMap::Entry* p =
map_.LookupOrInsert(reinterpret_cast<void*>(x), hash_(x));
CHECK(p != NULL); // insert is set!
CHECK_EQ(reinterpret_cast<void*>(x), p->key);
@@ -61,7 +61,8 @@
}
bool Present(int x) {
- HashMap::Entry* p = map_.Lookup(reinterpret_cast<void*>(x), hash_(x));
+ v8::base::HashMap::Entry* p =
+ map_.Lookup(reinterpret_cast<void*>(x), hash_(x));
if (p != NULL) {
CHECK_EQ(reinterpret_cast<void*>(x), p->key);
}
@@ -74,7 +75,8 @@
uint32_t occupancy() const {
uint32_t count = 0;
- for (HashMap::Entry* p = map_.Start(); p != NULL; p = map_.Next(p)) {
+ for (v8::base::HashMap::Entry* p = map_.Start(); p != NULL;
+ p = map_.Next(p)) {
count++;
}
CHECK_EQ(map_.occupancy(), static_cast<double>(count));
@@ -83,7 +85,7 @@
private:
IntKeyHash hash_;
- HashMap map_;
+ v8::base::HashMap map_;
};
diff --git a/test/cctest/test-heap-profiler.cc b/test/cctest/test-heap-profiler.cc
index 767c5cd..f8f1586 100644
--- a/test/cctest/test-heap-profiler.cc
+++ b/test/cctest/test-heap-profiler.cc
@@ -32,9 +32,9 @@
#include "src/v8.h"
#include "include/v8-profiler.h"
+#include "src/base/hashmap.h"
#include "src/collector.h"
#include "src/debug/debug.h"
-#include "src/hashmap.h"
#include "src/profiler/allocation-tracker.h"
#include "src/profiler/heap-profiler.h"
#include "src/profiler/heap-snapshot-generator-inl.h"
@@ -43,7 +43,6 @@
using i::AllocationTraceNode;
using i::AllocationTraceTree;
using i::AllocationTracker;
-using i::HashMap;
using i::ArrayVector;
using i::Vector;
@@ -66,7 +65,7 @@
}
void CheckAllReachables(i::HeapEntry* root) {
- i::HashMap visited(AddressesMatch);
+ v8::base::HashMap visited(AddressesMatch);
i::List<i::HeapEntry*> list(10);
list.Add(root);
CheckEntry(root);
@@ -76,7 +75,7 @@
for (int i = 0; i < children.length(); ++i) {
if (children[i]->type() == i::HeapGraphEdge::kShortcut) continue;
i::HeapEntry* child = children[i]->to();
- i::HashMap::Entry* entry = visited.LookupOrInsert(
+ v8::base::HashMap::Entry* entry = visited.LookupOrInsert(
reinterpret_cast<void*>(child),
static_cast<uint32_t>(reinterpret_cast<uintptr_t>(child)));
if (entry->value)
@@ -144,10 +143,10 @@
i::HeapSnapshot* heap_snapshot = const_cast<i::HeapSnapshot*>(
reinterpret_cast<const i::HeapSnapshot*>(snapshot));
- i::HashMap visited(AddressesMatch);
+ v8::base::HashMap visited(AddressesMatch);
i::List<i::HeapGraphEdge>& edges = heap_snapshot->edges();
for (int i = 0; i < edges.length(); ++i) {
- i::HashMap::Entry* entry = visited.LookupOrInsert(
+ v8::base::HashMap::Entry* entry = visited.LookupOrInsert(
reinterpret_cast<void*>(edges[i].to()),
static_cast<uint32_t>(reinterpret_cast<uintptr_t>(edges[i].to())));
uint32_t ref_count = static_cast<uint32_t>(
@@ -157,7 +156,7 @@
uint32_t unretained_entries_count = 0;
i::List<i::HeapEntry>& entries = heap_snapshot->entries();
for (int i = 0; i < entries.length(); ++i) {
- i::HashMap::Entry* entry = visited.Lookup(
+ v8::base::HashMap::Entry* entry = visited.Lookup(
reinterpret_cast<void*>(&entries[i]),
static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&entries[i])));
if (!entry && entries[i].id() != 1) {
diff --git a/test/cctest/test-inobject-slack-tracking.cc b/test/cctest/test-inobject-slack-tracking.cc
index 004781a..9f33d55 100644
--- a/test/cctest/test-inobject-slack-tracking.cc
+++ b/test/cctest/test-inobject-slack-tracking.cc
@@ -925,15 +925,14 @@
v8::HandleScope scope(CcTest::isolate());
const int first_field = 2;
- TestSubclassBuiltin("A1", JS_OBJECT_TYPE, "Error", "'err'", first_field);
- TestSubclassBuiltin("A2", JS_OBJECT_TYPE, "EvalError", "'err'", first_field);
- TestSubclassBuiltin("A3", JS_OBJECT_TYPE, "RangeError", "'err'", first_field);
- TestSubclassBuiltin("A4", JS_OBJECT_TYPE, "ReferenceError", "'err'",
+ TestSubclassBuiltin("A1", JS_ERROR_TYPE, "Error", "'err'", first_field);
+ TestSubclassBuiltin("A2", JS_ERROR_TYPE, "EvalError", "'err'", first_field);
+ TestSubclassBuiltin("A3", JS_ERROR_TYPE, "RangeError", "'err'", first_field);
+ TestSubclassBuiltin("A4", JS_ERROR_TYPE, "ReferenceError", "'err'",
first_field);
- TestSubclassBuiltin("A5", JS_OBJECT_TYPE, "SyntaxError", "'err'",
- first_field);
- TestSubclassBuiltin("A6", JS_OBJECT_TYPE, "TypeError", "'err'", first_field);
- TestSubclassBuiltin("A7", JS_OBJECT_TYPE, "URIError", "'err'", first_field);
+ TestSubclassBuiltin("A5", JS_ERROR_TYPE, "SyntaxError", "'err'", first_field);
+ TestSubclassBuiltin("A6", JS_ERROR_TYPE, "TypeError", "'err'", first_field);
+ TestSubclassBuiltin("A7", JS_ERROR_TYPE, "URIError", "'err'", first_field);
}
@@ -1100,7 +1099,7 @@
CcTest::InitializeVM();
v8::HandleScope scope(CcTest::isolate());
- const int first_field = 4;
+ const int first_field = 5;
TestSubclassBuiltin("A1", JS_PROMISE_TYPE, "Promise",
"function(resolve, reject) { resolve('ok'); }",
first_field);
diff --git a/test/cctest/test-log.cc b/test/cctest/test-log.cc
index c3856f2..b6bb256 100644
--- a/test/cctest/test-log.cc
+++ b/test/cctest/test-log.cc
@@ -376,7 +376,7 @@
#endif
i::EmbeddedVector<char, 100> ref_data;
i::SNPrintF(ref_data, "code-creation,Callback,-2,%p,1,\"method1\"",
- ObjMethod1_entry);
+ static_cast<void*>(ObjMethod1_entry));
CHECK(StrNStr(log.start(), ref_data.start(), log.length()));
log.Dispose();
@@ -429,7 +429,7 @@
EmbeddedVector<char, 100> prop1_getter_record;
i::SNPrintF(prop1_getter_record,
"code-creation,Callback,-2,%p,1,\"get prop1\"",
- Prop1Getter_entry);
+ static_cast<void*>(Prop1Getter_entry));
CHECK(StrNStr(log.start(), prop1_getter_record.start(), log.length()));
Address Prop1Setter_entry = reinterpret_cast<Address>(Prop1Setter);
@@ -439,7 +439,7 @@
EmbeddedVector<char, 100> prop1_setter_record;
i::SNPrintF(prop1_setter_record,
"code-creation,Callback,-2,%p,1,\"set prop1\"",
- Prop1Setter_entry);
+ static_cast<void*>(Prop1Setter_entry));
CHECK(StrNStr(log.start(), prop1_setter_record.start(), log.length()));
Address Prop2Getter_entry = reinterpret_cast<Address>(Prop2Getter);
@@ -449,7 +449,7 @@
EmbeddedVector<char, 100> prop2_getter_record;
i::SNPrintF(prop2_getter_record,
"code-creation,Callback,-2,%p,1,\"get prop2\"",
- Prop2Getter_entry);
+ static_cast<void*>(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 5408061..748198b 100644
--- a/test/cctest/test-macro-assembler-mips.cc
+++ b/test/cctest/test-macro-assembler-mips.cc
@@ -60,6 +60,71 @@
return true;
}
+TEST(BYTESWAP) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope handles(isolate);
+
+ struct T {
+ int32_t r1;
+ int32_t r2;
+ int32_t r3;
+ int32_t r4;
+ int32_t r5;
+ };
+ T t;
+
+ MacroAssembler assembler(isolate, NULL, 0,
+ v8::internal::CodeObjectRequired::kYes);
+ MacroAssembler* masm = &assembler;
+
+ __ lw(a2, MemOperand(a0, offsetof(T, r1)));
+ __ nop();
+ __ ByteSwapSigned(a2, 4);
+ __ sw(a2, MemOperand(a0, offsetof(T, r1)));
+
+ __ lw(a2, MemOperand(a0, offsetof(T, r2)));
+ __ nop();
+ __ ByteSwapSigned(a2, 2);
+ __ sw(a2, MemOperand(a0, offsetof(T, r2)));
+
+ __ lw(a2, MemOperand(a0, offsetof(T, r3)));
+ __ nop();
+ __ ByteSwapSigned(a2, 1);
+ __ sw(a2, MemOperand(a0, offsetof(T, r3)));
+
+ __ lw(a2, MemOperand(a0, offsetof(T, r4)));
+ __ nop();
+ __ ByteSwapUnsigned(a2, 1);
+ __ sw(a2, MemOperand(a0, offsetof(T, r4)));
+
+ __ lw(a2, MemOperand(a0, offsetof(T, r5)));
+ __ nop();
+ __ ByteSwapUnsigned(a2, 2);
+ __ sw(a2, MemOperand(a0, offsetof(T, r5)));
+
+ __ jr(ra);
+ __ nop();
+
+ CodeDesc desc;
+ masm->GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+ ::F3 f = FUNCTION_CAST<::F3>(code->entry());
+ t.r1 = 0x781A15C3;
+ t.r2 = 0x2CDE;
+ t.r3 = 0x9F;
+ t.r4 = 0x9F;
+ t.r5 = 0x2CDE;
+ Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
+ USE(dummy);
+
+ CHECK_EQ(static_cast<int32_t>(0xC3151A78), t.r1);
+ CHECK_EQ(static_cast<int32_t>(0xDE2C0000), t.r2);
+ CHECK_EQ(static_cast<int32_t>(0x9FFFFFFF), t.r3);
+ CHECK_EQ(static_cast<int32_t>(0x9F000000), t.r4);
+ CHECK_EQ(static_cast<int32_t>(0xDE2C0000), t.r5);
+}
TEST(CopyBytes) {
CcTest::InitializeVM();
diff --git a/test/cctest/test-macro-assembler-mips64.cc b/test/cctest/test-macro-assembler-mips64.cc
index f0180c1..258ac40 100644
--- a/test/cctest/test-macro-assembler-mips64.cc
+++ b/test/cctest/test-macro-assembler-mips64.cc
@@ -61,6 +61,89 @@
return true;
}
+TEST(BYTESWAP) {
+ DCHECK(kArchVariant == kMips64r6 || kArchVariant == kMips64r2);
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+
+ struct T {
+ int64_t r1;
+ int64_t r2;
+ int64_t r3;
+ int64_t r4;
+ int64_t r5;
+ int64_t r6;
+ int64_t r7;
+ };
+ T t;
+
+ MacroAssembler assembler(isolate, NULL, 0,
+ v8::internal::CodeObjectRequired::kYes);
+
+ MacroAssembler* masm = &assembler;
+
+ __ ld(a4, MemOperand(a0, offsetof(T, r1)));
+ __ nop();
+ __ ByteSwapSigned(a4, 8);
+ __ sd(a4, MemOperand(a0, offsetof(T, r1)));
+
+ __ ld(a4, MemOperand(a0, offsetof(T, r2)));
+ __ nop();
+ __ ByteSwapSigned(a4, 4);
+ __ sd(a4, MemOperand(a0, offsetof(T, r2)));
+
+ __ ld(a4, MemOperand(a0, offsetof(T, r3)));
+ __ nop();
+ __ ByteSwapSigned(a4, 2);
+ __ sd(a4, MemOperand(a0, offsetof(T, r3)));
+
+ __ ld(a4, MemOperand(a0, offsetof(T, r4)));
+ __ nop();
+ __ ByteSwapSigned(a4, 1);
+ __ sd(a4, MemOperand(a0, offsetof(T, r4)));
+
+ __ ld(a4, MemOperand(a0, offsetof(T, r5)));
+ __ nop();
+ __ ByteSwapUnsigned(a4, 1);
+ __ sd(a4, MemOperand(a0, offsetof(T, r5)));
+
+ __ ld(a4, MemOperand(a0, offsetof(T, r6)));
+ __ nop();
+ __ ByteSwapUnsigned(a4, 2);
+ __ sd(a4, MemOperand(a0, offsetof(T, r6)));
+
+ __ ld(a4, MemOperand(a0, offsetof(T, r7)));
+ __ nop();
+ __ ByteSwapUnsigned(a4, 4);
+ __ sd(a4, MemOperand(a0, offsetof(T, r7)));
+
+ __ jr(ra);
+ __ nop();
+
+ CodeDesc desc;
+ masm->GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+ ::F3 f = FUNCTION_CAST<::F3>(code->entry());
+ t.r1 = 0x5612FFCD9D327ACC;
+ t.r2 = 0x781A15C3;
+ t.r3 = 0xFCDE;
+ t.r4 = 0x9F;
+ t.r5 = 0x9F;
+ t.r6 = 0xFCDE;
+ t.r7 = 0xC81A15C3;
+ Object* dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0);
+ USE(dummy);
+
+ CHECK_EQ(static_cast<int64_t>(0xCC7A329DCDFF1256), t.r1);
+ CHECK_EQ(static_cast<int64_t>(0xC3151A7800000000), t.r2);
+ CHECK_EQ(static_cast<int64_t>(0xDEFCFFFFFFFFFFFF), t.r3);
+ CHECK_EQ(static_cast<int64_t>(0x9FFFFFFFFFFFFFFF), t.r4);
+ CHECK_EQ(static_cast<int64_t>(0x9F00000000000000), t.r5);
+ CHECK_EQ(static_cast<int64_t>(0xDEFC000000000000), t.r6);
+ CHECK_EQ(static_cast<int64_t>(0xC3151AC800000000), t.r7);
+}
TEST(CopyBytes) {
CcTest::InitializeVM();
diff --git a/test/cctest/test-parsing.cc b/test/cctest/test-parsing.cc
index 36f7293..ab1fc76 100644
--- a/test/cctest/test-parsing.cc
+++ b/test/cctest/test-parsing.cc
@@ -1509,7 +1509,8 @@
kAllowHarmonyRestrictiveDeclarations,
kAllowHarmonyExponentiationOperator,
kAllowHarmonyForIn,
- kAllowHarmonyAsyncAwait
+ kAllowHarmonyAsyncAwait,
+ kAllowHarmonyRestrictiveGenerators,
};
enum ParserSyncTestResult {
@@ -1532,6 +1533,8 @@
parser->set_allow_harmony_for_in(flags.Contains(kAllowHarmonyForIn));
parser->set_allow_harmony_async_await(
flags.Contains(kAllowHarmonyAsyncAwait));
+ parser->set_allow_harmony_restrictive_generators(
+ flags.Contains(kAllowHarmonyRestrictiveGenerators));
}
@@ -3566,10 +3569,8 @@
CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
CompileRun("\"use asm\";\n"
"var foo = 1;\n"
- "\"use asm\";\n" // Only the first one counts.
"function bar() { \"use asm\"; var baz = 1; }");
- // Optimizing will double-count because the source is parsed twice.
- CHECK_EQ(i::FLAG_always_opt ? 4 : 2, use_counts[v8::Isolate::kUseAsm]);
+ CHECK_LT(0, use_counts[v8::Isolate::kUseAsm]);
}
@@ -7503,6 +7504,9 @@
"var O = { async 'method'() { await 1; } }",
"var O = { async 0() { await 1; } }",
"async function await() {}",
+
+ "var asyncFn = async({ foo = 1 }) => foo;",
+ "var asyncFn = async({ foo = 1 } = {}) => foo;",
NULL
};
// clang-format on
@@ -7639,6 +7643,35 @@
"var O = { async method() { function await() {} } }",
"async function foo() { function await() {} }",
+ // Henrique Ferreiro's bug (tm)
+ "(async function foo() { } foo => 1)",
+ "(async function foo() { } () => 1)",
+ "(async function foo() { } => 1)",
+ "(async function() { } foo => 1)",
+ "(async function() { } () => 1)",
+ "(async function() { } => 1)",
+ "(async.foo => 1)",
+ "(async.foo foo => 1)",
+ "(async.foo () => 1)",
+ "(async().foo => 1)",
+ "(async().foo foo => 1)",
+ "(async().foo () => 1)",
+ "(async['foo'] => 1)",
+ "(async['foo'] foo => 1)",
+ "(async['foo'] () => 1)",
+ "(async()['foo'] => 1)",
+ "(async()['foo'] foo => 1)",
+ "(async()['foo'] () => 1)",
+ "(async`foo` => 1)",
+ "(async`foo` foo => 1)",
+ "(async`foo` () => 1)",
+ "(async`foo`.bar => 1)",
+ "(async`foo`.bar foo => 1)",
+ "(async`foo`.bar () => 1)",
+
+ // v8:5148 assert that errors are still thrown for calls that may have been
+ // async functions
+ "async({ foo = 1 })",
NULL
};
@@ -7660,6 +7693,22 @@
NULL
};
+
+ const char* formal_parameters_data[] = {
+ "var f = async({ await }) => 1;",
+ "var f = async({ await = 1 }) => 1;",
+ "var f = async({ await } = {}) => 1;",
+ "var f = async({ await = 1 } = {}) => 1;",
+ "var f = async([await]) => 1;",
+ "var f = async([await] = []) => 1;",
+ "var f = async([await = 1]) => 1;",
+ "var f = async([await = 1] = []) => 1;",
+ "var f = async(...await) => 1;",
+ "var f = async(await) => 1;",
+ "var f = async(await = 1) => 1;",
+ "var f = async(...[await]) => 1;",
+ NULL
+ };
// clang-format on
static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
@@ -7667,6 +7716,9 @@
arraysize(always_flags));
RunParserSyncTest(strict_context_data, strict_error_data, kError, NULL, 0,
always_flags, arraysize(always_flags));
+
+ RunParserSyncTest(context_data, formal_parameters_data, kError, NULL, 0,
+ always_flags, arraysize(always_flags));
}
TEST(AsyncAwaitModule) {
@@ -7731,3 +7783,60 @@
RunParserSyncTest(context_data, error_data, kError, nullptr, 0, always_flags,
arraysize(always_flags));
}
+
+TEST(NoDuplicateGeneratorsInBlock) {
+ const char* block_context_data[][2] = {
+ {"'use strict'; {", "}"},
+ {"{", "}"},
+ {"(function() { {", "} })()"},
+ {"(function() {'use strict'; {", "} })()"},
+ {NULL, NULL}};
+ const char* top_level_context_data[][2] = {
+ {"'use strict';", ""},
+ {"", ""},
+ {"(function() {", "})()"},
+ {"(function() {'use strict';", "})()"},
+ {NULL, NULL}};
+ const char* error_data[] = {"function* x() {} function* x() {}",
+ "function x() {} function* x() {}",
+ "function* x() {} function x() {}", NULL};
+ static const ParserFlag always_flags[] = {kAllowHarmonyRestrictiveGenerators};
+ // The preparser doesn't enforce the restriction, so turn it off.
+ bool test_preparser = false;
+ RunParserSyncTest(block_context_data, error_data, kError, NULL, 0,
+ always_flags, arraysize(always_flags), NULL, 0, false,
+ test_preparser);
+ RunParserSyncTest(top_level_context_data, error_data, kSuccess, NULL, 0,
+ always_flags, arraysize(always_flags));
+}
+
+TEST(NoDuplicateAsyncFunctionInBlock) {
+ const char* block_context_data[][2] = {
+ {"'use strict'; {", "}"},
+ {"{", "}"},
+ {"(function() { {", "} })()"},
+ {"(function() {'use strict'; {", "} })()"},
+ {NULL, NULL}};
+ const char* top_level_context_data[][2] = {
+ {"'use strict';", ""},
+ {"", ""},
+ {"(function() {", "})()"},
+ {"(function() {'use strict';", "})()"},
+ {NULL, NULL}};
+ const char* error_data[] = {"async function x() {} async function x() {}",
+ "function x() {} async function x() {}",
+ "async function x() {} function x() {}",
+ "function* x() {} async function x() {}",
+ "function* x() {} async function x() {}",
+ "async function x() {} function* x() {}",
+ "function* x() {} async function x() {}",
+ NULL};
+ static const ParserFlag always_flags[] = {kAllowHarmonyAsyncAwait};
+ // The preparser doesn't enforce the restriction, so turn it off.
+ bool test_preparser = false;
+ RunParserSyncTest(block_context_data, error_data, kError, NULL, 0,
+ always_flags, arraysize(always_flags), NULL, 0, false,
+ test_preparser);
+ RunParserSyncTest(top_level_context_data, error_data, kSuccess, NULL, 0,
+ always_flags, arraysize(always_flags));
+}
diff --git a/test/cctest/test-platform.cc b/test/cctest/test-platform.cc
index 48eda3d..a0fbc21 100644
--- a/test/cctest/test-platform.cc
+++ b/test/cctest/test-platform.cc
@@ -17,7 +17,7 @@
#elif V8_HOST_ARCH_IA32
__asm__ __volatile__("mov %%esp, %0" : "=g"(sp_addr));
#elif V8_HOST_ARCH_ARM
- __asm__ __volatile__("str %%sp, %0" : "=g"(sp_addr));
+ __asm__ __volatile__("str sp, %0" : "=g"(sp_addr));
#elif V8_HOST_ARCH_ARM64
__asm__ __volatile__("mov x16, sp; str x16, %0" : "=g"(sp_addr));
#elif V8_HOST_ARCH_MIPS
diff --git a/test/cctest/test-profile-generator.cc b/test/cctest/test-profile-generator.cc
index 71c5ba8..7e59839 100644
--- a/test/cctest/test-profile-generator.cc
+++ b/test/cctest/test-profile-generator.cc
@@ -51,17 +51,17 @@
CcTest::InitializeVM();
ProfileTree tree(CcTest::i_isolate());
ProfileNode* node = tree.root();
- CodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa");
+ CodeEntry entry1(i::CodeEventListener::FUNCTION_TAG, "aaa");
ProfileNode* childNode1 = node->FindOrAddChild(&entry1);
CHECK(childNode1);
CHECK_EQ(childNode1, node->FindOrAddChild(&entry1));
- CodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb");
+ CodeEntry entry2(i::CodeEventListener::FUNCTION_TAG, "bbb");
ProfileNode* childNode2 = node->FindOrAddChild(&entry2);
CHECK(childNode2);
CHECK_NE(childNode1, childNode2);
CHECK_EQ(childNode1, node->FindOrAddChild(&entry1));
CHECK_EQ(childNode2, node->FindOrAddChild(&entry2));
- CodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc");
+ CodeEntry entry3(i::CodeEventListener::FUNCTION_TAG, "ccc");
ProfileNode* childNode3 = node->FindOrAddChild(&entry3);
CHECK(childNode3);
CHECK_NE(childNode1, childNode3);
@@ -77,15 +77,15 @@
const char* aaa = "aaa";
ProfileTree tree(CcTest::i_isolate());
ProfileNode* node = tree.root();
- CodeEntry entry1(i::Logger::FUNCTION_TAG, aaa);
+ CodeEntry entry1(i::CodeEventListener::FUNCTION_TAG, aaa);
ProfileNode* childNode1 = node->FindOrAddChild(&entry1);
CHECK(childNode1);
CHECK_EQ(childNode1, node->FindOrAddChild(&entry1));
// The same function again.
- CodeEntry entry2(i::Logger::FUNCTION_TAG, aaa);
+ CodeEntry entry2(i::CodeEventListener::FUNCTION_TAG, aaa);
CHECK_EQ(childNode1, node->FindOrAddChild(&entry2));
// Now with a different security token.
- CodeEntry entry3(i::Logger::FUNCTION_TAG, aaa);
+ CodeEntry entry3(i::CodeEventListener::FUNCTION_TAG, aaa);
CHECK_EQ(childNode1, node->FindOrAddChild(&entry3));
}
@@ -122,9 +122,9 @@
TEST(ProfileTreeAddPathFromEnd) {
CcTest::InitializeVM();
- CodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa");
- CodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb");
- CodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc");
+ CodeEntry entry1(i::CodeEventListener::FUNCTION_TAG, "aaa");
+ CodeEntry entry2(i::CodeEventListener::FUNCTION_TAG, "bbb");
+ CodeEntry entry3(i::CodeEventListener::FUNCTION_TAG, "ccc");
ProfileTree tree(CcTest::i_isolate());
ProfileTreeTestHelper helper(&tree);
CHECK(!helper.Walk(&entry1));
@@ -187,7 +187,7 @@
empty_tree.root()->IncrementSelfTicks();
CHECK_EQ(1u, empty_tree.root()->self_ticks());
- CodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa");
+ CodeEntry entry1(i::CodeEventListener::FUNCTION_TAG, "aaa");
CodeEntry* e1_path[] = {&entry1};
std::vector<CodeEntry*> e1_path_vec(e1_path, e1_path + arraysize(e1_path));
@@ -201,7 +201,7 @@
CHECK_EQ(1u, single_child_tree.root()->self_ticks());
CHECK_EQ(1u, node1->self_ticks());
- CodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb");
+ CodeEntry entry2(i::CodeEventListener::FUNCTION_TAG, "bbb");
CodeEntry* e2_e1_path[] = {&entry2, &entry1};
std::vector<CodeEntry*> e2_e1_path_vec(e2_e1_path,
e2_e1_path + arraysize(e2_e1_path));
@@ -227,7 +227,7 @@
CodeEntry* e2_path[] = {&entry2};
std::vector<CodeEntry*> e2_path_vec(e2_path, e2_path + arraysize(e2_path));
- CodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc");
+ CodeEntry entry3(i::CodeEventListener::FUNCTION_TAG, "ccc");
CodeEntry* e3_path[] = {&entry3};
std::vector<CodeEntry*> e3_path_vec(e3_path, e3_path + arraysize(e3_path));
@@ -277,10 +277,10 @@
TEST(CodeMapAddCode) {
CodeMap code_map;
- CodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa");
- CodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb");
- CodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc");
- CodeEntry entry4(i::Logger::FUNCTION_TAG, "ddd");
+ CodeEntry entry1(i::CodeEventListener::FUNCTION_TAG, "aaa");
+ CodeEntry entry2(i::CodeEventListener::FUNCTION_TAG, "bbb");
+ CodeEntry entry3(i::CodeEventListener::FUNCTION_TAG, "ccc");
+ CodeEntry entry4(i::CodeEventListener::FUNCTION_TAG, "ddd");
code_map.AddCode(ToAddress(0x1500), &entry1, 0x200);
code_map.AddCode(ToAddress(0x1700), &entry2, 0x100);
code_map.AddCode(ToAddress(0x1900), &entry3, 0x50);
@@ -307,8 +307,8 @@
TEST(CodeMapMoveAndDeleteCode) {
CodeMap code_map;
- CodeEntry entry1(i::Logger::FUNCTION_TAG, "aaa");
- CodeEntry entry2(i::Logger::FUNCTION_TAG, "bbb");
+ CodeEntry entry1(i::CodeEventListener::FUNCTION_TAG, "aaa");
+ CodeEntry entry2(i::CodeEventListener::FUNCTION_TAG, "bbb");
code_map.AddCode(ToAddress(0x1500), &entry1, 0x200);
code_map.AddCode(ToAddress(0x1700), &entry2, 0x100);
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1500)));
@@ -316,7 +316,7 @@
code_map.MoveCode(ToAddress(0x1500), ToAddress(0x1700)); // Deprecate bbb.
CHECK(!code_map.FindEntry(ToAddress(0x1500)));
CHECK_EQ(&entry1, code_map.FindEntry(ToAddress(0x1700)));
- CodeEntry entry3(i::Logger::FUNCTION_TAG, "ccc");
+ CodeEntry entry3(i::CodeEventListener::FUNCTION_TAG, "ccc");
code_map.AddCode(ToAddress(0x1750), &entry3, 0x100);
CHECK(!code_map.FindEntry(ToAddress(0x1700)));
CHECK_EQ(&entry3, code_map.FindEntry(ToAddress(0x1750)));
@@ -344,12 +344,13 @@
TEST(RecordTickSample) {
TestSetup test_setup;
- CpuProfilesCollection profiles(CcTest::heap());
+ CpuProfilesCollection profiles(CcTest::i_isolate());
+ profiles.set_cpu_profiler(CcTest::i_isolate()->cpu_profiler());
profiles.StartProfiling("", false);
ProfileGenerator generator(&profiles);
- CodeEntry* entry1 = profiles.NewCodeEntry(i::Logger::FUNCTION_TAG, "aaa");
- CodeEntry* entry2 = profiles.NewCodeEntry(i::Logger::FUNCTION_TAG, "bbb");
- CodeEntry* entry3 = profiles.NewCodeEntry(i::Logger::FUNCTION_TAG, "ccc");
+ CodeEntry* entry1 = new CodeEntry(i::Logger::FUNCTION_TAG, "aaa");
+ CodeEntry* entry2 = new CodeEntry(i::Logger::FUNCTION_TAG, "bbb");
+ CodeEntry* entry3 = new CodeEntry(i::Logger::FUNCTION_TAG, "ccc");
generator.code_map()->AddCode(ToAddress(0x1500), entry1, 0x200);
generator.code_map()->AddCode(ToAddress(0x1700), entry2, 0x100);
generator.code_map()->AddCode(ToAddress(0x1900), entry3, 0x50);
@@ -397,6 +398,10 @@
ProfileNode* node4 = top_down_test_helper.Walk(entry1, entry3, entry1);
CHECK(node4);
CHECK_EQ(entry1, node4->entry());
+
+ delete entry1;
+ delete entry2;
+ delete entry3;
}
@@ -410,12 +415,13 @@
TEST(SampleIds) {
TestSetup test_setup;
- CpuProfilesCollection profiles(CcTest::heap());
+ CpuProfilesCollection profiles(CcTest::i_isolate());
+ profiles.set_cpu_profiler(CcTest::i_isolate()->cpu_profiler());
profiles.StartProfiling("", true);
ProfileGenerator generator(&profiles);
- CodeEntry* entry1 = profiles.NewCodeEntry(i::Logger::FUNCTION_TAG, "aaa");
- CodeEntry* entry2 = profiles.NewCodeEntry(i::Logger::FUNCTION_TAG, "bbb");
- CodeEntry* entry3 = profiles.NewCodeEntry(i::Logger::FUNCTION_TAG, "ccc");
+ CodeEntry* entry1 = new CodeEntry(i::Logger::FUNCTION_TAG, "aaa");
+ CodeEntry* entry2 = new CodeEntry(i::Logger::FUNCTION_TAG, "bbb");
+ CodeEntry* entry3 = new CodeEntry(i::Logger::FUNCTION_TAG, "ccc");
generator.code_map()->AddCode(ToAddress(0x1500), entry1, 0x200);
generator.code_map()->AddCode(ToAddress(0x1700), entry2, 0x100);
generator.code_map()->AddCode(ToAddress(0x1900), entry3, 0x50);
@@ -456,15 +462,20 @@
for (int i = 0; i < 3; i++) {
CHECK_EQ(expected_id[i], profile->sample(i)->id());
}
+
+ delete entry1;
+ delete entry2;
+ delete entry3;
}
TEST(NoSamples) {
TestSetup test_setup;
- CpuProfilesCollection profiles(CcTest::heap());
+ CpuProfilesCollection profiles(CcTest::i_isolate());
+ profiles.set_cpu_profiler(CcTest::i_isolate()->cpu_profiler());
profiles.StartProfiling("", false);
ProfileGenerator generator(&profiles);
- CodeEntry* entry1 = profiles.NewCodeEntry(i::Logger::FUNCTION_TAG, "aaa");
+ CodeEntry* entry1 = new CodeEntry(i::Logger::FUNCTION_TAG, "aaa");
generator.code_map()->AddCode(ToAddress(0x1500), entry1, 0x200);
// We are building the following calls tree:
@@ -481,6 +492,8 @@
CHECK_EQ(3u, nodeId - 1);
CHECK_EQ(0, profile->samples_count());
+
+ delete entry1;
}
@@ -544,7 +557,8 @@
TEST(Issue51919) {
- CpuProfilesCollection collection(CcTest::heap());
+ CpuProfilesCollection collection(CcTest::i_isolate());
+ collection.set_cpu_profiler(CcTest::i_isolate()->cpu_profiler());
i::EmbeddedVector<char*,
CpuProfilesCollection::kMaxSimultaneousProfiles> titles;
for (int i = 0; i < CpuProfilesCollection::kMaxSimultaneousProfiles; ++i) {
@@ -618,16 +632,12 @@
CHECK_EQ(script_a->GetUnboundScript()->GetId(), current->GetScriptId());
}
-
-
-
static const char* line_number_test_source_existing_functions =
"function foo_at_the_first_line() {\n"
"}\n"
"foo_at_the_first_line();\n"
"function lazy_func_at_forth_line() {}\n";
-
static const char* line_number_test_source_profile_time_functions =
"// Empty first line\n"
"function bar_at_the_second_line() {\n"
@@ -652,7 +662,6 @@
return func_entry->line_number();
}
-
TEST(LineNumber) {
i::FLAG_use_inlining = false;
@@ -683,8 +692,6 @@
profiler->StopProfiling("LineNumber");
}
-
-
TEST(BailoutReason) {
v8::HandleScope scope(CcTest::isolate());
v8::Local<v8::Context> env = CcTest::NewContext(PROFILER_EXTENSION);
diff --git a/test/cctest/test-regexp.cc b/test/cctest/test-regexp.cc
index 0a153b7..071ab18 100644
--- a/test/cctest/test-regexp.cc
+++ b/test/cctest/test-regexp.cc
@@ -171,7 +171,6 @@
void TestRegExpParser(bool lookbehind) {
FLAG_harmony_regexp_lookbehind = lookbehind;
- FLAG_harmony_unicode_regexps = true;
CHECK_PARSE_ERROR("?");
@@ -438,6 +437,23 @@
CHECK_MIN_MAX("a(?=b)c", 2, 2);
CHECK_MIN_MAX("a(?=bbb|bb)c", 2, 2);
CHECK_MIN_MAX("a(?!bbb|bb)c", 2, 2);
+
+ FLAG_harmony_regexp_named_captures = true;
+ CheckParseEq("(?<a>x)(?<b>x)(?<c>x)\\k<a>",
+ "(: (^ 'x') (^ 'x') (^ 'x') (<- 1))", true);
+ CheckParseEq("(?<a>x)(?<b>x)(?<c>x)\\k<b>",
+ "(: (^ 'x') (^ 'x') (^ 'x') (<- 2))", true);
+ CheckParseEq("(?<a>x)(?<b>x)(?<c>x)\\k<c>",
+ "(: (^ 'x') (^ 'x') (^ 'x') (<- 3))", true);
+ CheckParseEq("(?<a>a)\\k<a>", "(: (^ 'a') (<- 1))", true);
+ CheckParseEq("(?<a>a\\k<a>)", "(^ 'a')", true);
+ CheckParseEq("(?<a>\\k<a>a)", "(^ 'a')", true);
+ CheckParseEq("(?<a>\\k<b>)(?<b>\\k<a>)", "(: (^ (<- 2)) (^ (<- 1)))", true);
+ CheckParseEq("\\k<a>(?<a>a)", "(: (<- 1) (^ 'a'))", true);
+
+ CheckParseEq("(?<\\u{03C0}>a)", "(^ 'a')", true);
+ CheckParseEq("(?<\\u03C0>a)", "(^ 'a')", true);
+ FLAG_harmony_regexp_named_captures = false;
}
@@ -450,7 +466,6 @@
TestRegExpParser(true); // Lookbehind enabled.
}
-
TEST(ParserRegression) {
CheckParseEq("[A-Z$-][x]", "(! [A-Z $ -] [x])");
CheckParseEq("a{3,4*}", "(: 'a{3,' (# 0 - g '4') '}')");
@@ -458,14 +473,16 @@
CheckParseEq("a|", "(| 'a' %)");
}
-static void ExpectError(const char* input,
- const char* expected) {
+static void ExpectError(const char* input, const char* expected,
+ bool unicode = false) {
v8::HandleScope scope(CcTest::isolate());
Zone zone(CcTest::i_isolate()->allocator());
FlatStringReader reader(CcTest::i_isolate(), CStrVector(input));
RegExpCompileData result;
- CHECK(!v8::internal::RegExpParser::ParseRegExp(
- CcTest::i_isolate(), &zone, &reader, JSRegExp::kNone, &result));
+ JSRegExp::Flags flags = JSRegExp::kNone;
+ if (unicode) flags |= JSRegExp::kUnicode;
+ CHECK(!v8::internal::RegExpParser::ParseRegExp(CcTest::i_isolate(), &zone,
+ &reader, flags, &result));
CHECK(result.tree == NULL);
CHECK(!result.error.is_null());
v8::base::SmartArrayPointer<char> str = result.error->ToCString(ALLOW_NULLS);
@@ -499,6 +516,23 @@
os << "()";
}
ExpectError(os.str().c_str(), kTooManyCaptures);
+
+ FLAG_harmony_regexp_named_captures = true;
+ const char* kInvalidCaptureName = "Invalid capture group name";
+ ExpectError("(?<>.)", kInvalidCaptureName, true);
+ ExpectError("(?<1>.)", kInvalidCaptureName, true);
+ ExpectError("(?<_%>.)", kInvalidCaptureName, true);
+ ExpectError("\\k<a", kInvalidCaptureName, true);
+ const char* kDuplicateCaptureName = "Duplicate capture group name";
+ ExpectError("(?<a>.)(?<a>.)", kDuplicateCaptureName, true);
+ const char* kInvalidUnicodeEscape = "Invalid Unicode escape sequence";
+ ExpectError("(?<\\u{FISK}", kInvalidUnicodeEscape, true);
+ const char* kInvalidCaptureReferenced = "Invalid named capture referenced";
+ ExpectError("\\k<a>", kInvalidCaptureReferenced, true);
+ ExpectError("(?<b>)\\k<a>", kInvalidCaptureReferenced, true);
+ const char* kInvalidNamedReference = "Invalid named reference";
+ ExpectError("\\ka", kInvalidNamedReference, true);
+ FLAG_harmony_regexp_named_captures = false;
}
diff --git a/test/cctest/test-reloc-info.cc b/test/cctest/test-reloc-info.cc
index 4346f00..52b5ab8 100644
--- a/test/cctest/test-reloc-info.cc
+++ b/test/cctest/test-reloc-info.cc
@@ -57,9 +57,9 @@
RelocInfo::Mode mode = (i % 2 == 0) ?
RelocInfo::STATEMENT_POSITION : RelocInfo::POSITION;
if (mode == RelocInfo::STATEMENT_POSITION) {
- printf("TEST WRITING STATEMENT %p %d\n", pc, pos);
+ printf("TEST WRITING STATEMENT %p %d\n", static_cast<void*>(pc), pos);
} else {
- printf("TEST WRITING POSITION %p %d\n", pc, pos);
+ printf("TEST WRITING POSITION %p %d\n", static_cast<void*>(pc), pos);
}
WriteRinfo(&writer, pc, mode, pos);
CHECK(writer.pos() - RelocInfoWriter::kMaxSize >= relocation_info_end);
@@ -68,8 +68,9 @@
writer.Finish();
relocation_info_size = static_cast<int>(buffer_end - writer.pos());
MacroAssembler assm(CcTest::i_isolate(), nullptr, 0, CodeObjectRequired::kNo);
- CodeDesc desc = {buffer.get(), buffer_size, code_size,
- relocation_info_size, 0, &assm};
+ CodeDesc desc = {
+ buffer.get(), buffer_size, code_size, relocation_info_size, 0,
+ nullptr, 0, &assm};
// Read only (non-statement) positions.
{
diff --git a/test/cctest/test-serialize.cc b/test/cctest/test-serialize.cc
index cd349f9..de36877 100644
--- a/test/cctest/test-serialize.cc
+++ b/test/cctest/test-serialize.cc
@@ -36,6 +36,7 @@
#include "src/compilation-cache.h"
#include "src/debug/debug.h"
#include "src/heap/spaces.h"
+#include "src/macro-assembler.h"
#include "src/objects.h"
#include "src/parsing/parser.h"
#include "src/runtime/runtime.h"
@@ -46,7 +47,7 @@
#include "src/snapshot/snapshot.h"
#include "src/snapshot/startup-serializer.h"
#include "test/cctest/cctest.h"
-#include "test/cctest/heap/utils-inl.h"
+#include "test/cctest/heap/heap-utils.h"
using namespace v8::internal;
@@ -91,11 +92,11 @@
Isolate* internal_isolate = reinterpret_cast<Isolate*>(isolate);
internal_isolate->heap()->CollectAllAvailableGarbage("serialize");
- SnapshotByteSink sink;
- StartupSerializer ser(internal_isolate, &sink);
+ StartupSerializer ser(internal_isolate,
+ v8::SnapshotCreator::FunctionCodeHandling::kClear);
ser.SerializeStrongReferences();
ser.SerializeWeakReferencesAndDeferred();
- SnapshotData snapshot_data(ser);
+ SnapshotData snapshot_data(&ser);
return WritePayload(snapshot_data.RawData());
}
@@ -280,19 +281,17 @@
}
env.Reset();
- SnapshotByteSink startup_sink;
- StartupSerializer startup_serializer(isolate, &startup_sink);
+ StartupSerializer startup_serializer(
+ isolate, v8::SnapshotCreator::FunctionCodeHandling::kClear);
startup_serializer.SerializeStrongReferences();
- SnapshotByteSink partial_sink;
- PartialSerializer partial_serializer(isolate, &startup_serializer,
- &partial_sink);
+ PartialSerializer partial_serializer(isolate, &startup_serializer);
partial_serializer.Serialize(&raw_foo);
startup_serializer.SerializeWeakReferencesAndDeferred();
- SnapshotData startup_snapshot(startup_serializer);
- SnapshotData partial_snapshot(partial_serializer);
+ SnapshotData startup_snapshot(&startup_serializer);
+ SnapshotData partial_snapshot(&partial_serializer);
*partial_blob_out = WritePayload(partial_snapshot.RawData());
*startup_blob_out = WritePayload(startup_snapshot.RawData());
@@ -380,17 +379,17 @@
env.Reset();
SnapshotByteSink startup_sink;
- StartupSerializer startup_serializer(isolate, &startup_sink);
+ StartupSerializer startup_serializer(
+ isolate, v8::SnapshotCreator::FunctionCodeHandling::kClear);
startup_serializer.SerializeStrongReferences();
SnapshotByteSink partial_sink;
- PartialSerializer partial_serializer(isolate, &startup_serializer,
- &partial_sink);
+ PartialSerializer partial_serializer(isolate, &startup_serializer);
partial_serializer.Serialize(&raw_context);
startup_serializer.SerializeWeakReferencesAndDeferred();
- SnapshotData startup_snapshot(startup_serializer);
- SnapshotData partial_snapshot(partial_serializer);
+ SnapshotData startup_snapshot(&startup_serializer);
+ SnapshotData partial_snapshot(&partial_serializer);
*partial_blob_out = WritePayload(partial_snapshot.RawData());
*startup_blob_out = WritePayload(startup_snapshot.RawData());
@@ -498,17 +497,17 @@
env.Reset();
SnapshotByteSink startup_sink;
- StartupSerializer startup_serializer(isolate, &startup_sink);
+ StartupSerializer startup_serializer(
+ isolate, v8::SnapshotCreator::FunctionCodeHandling::kClear);
startup_serializer.SerializeStrongReferences();
SnapshotByteSink partial_sink;
- PartialSerializer partial_serializer(isolate, &startup_serializer,
- &partial_sink);
+ PartialSerializer partial_serializer(isolate, &startup_serializer);
partial_serializer.Serialize(&raw_context);
startup_serializer.SerializeWeakReferencesAndDeferred();
- SnapshotData startup_snapshot(startup_serializer);
- SnapshotData partial_snapshot(partial_serializer);
+ SnapshotData startup_snapshot(&startup_serializer);
+ SnapshotData partial_snapshot(&partial_serializer);
*partial_blob_out = WritePayload(partial_snapshot.RawData());
*startup_blob_out = WritePayload(startup_snapshot.RawData());
@@ -792,7 +791,7 @@
TEST(SnapshotDataBlobWithWarmup) {
DisableTurbofan();
- const char* warmup = "Math.tan(1); Math.sin = 1;";
+ const char* warmup = "Math.tanh(1); Math.sinh = 1;";
v8::StartupData cold = v8::V8::CreateSnapshotDataBlob();
v8::StartupData warm = v8::V8::WarmUpSnapshotDataBlob(cold, warmup);
@@ -811,9 +810,9 @@
v8::Context::Scope c_scope(context);
// Running the warmup script has effect on whether functions are
// pre-compiled, but does not pollute the context.
- CHECK(IsCompiled("Math.tan"));
- CHECK(!IsCompiled("Math.cos"));
- CHECK(CompileRun("Math.sin")->IsFunction());
+ CHECK(IsCompiled("Math.tanh"));
+ CHECK(!IsCompiled("Math.cosh"));
+ CHECK(CompileRun("Math.sinh")->IsFunction());
}
isolate->Dispose();
}
@@ -821,9 +820,9 @@
TEST(CustomSnapshotDataBlobWithWarmup) {
DisableTurbofan();
const char* source =
- "function f() { return Math.sin(1); }\n"
- "function g() { return Math.cos(1); }\n"
- "Math.tan(1);"
+ "function f() { return Math.sinh(1); }\n"
+ "function g() { return Math.cosh(1); }\n"
+ "Math.tanh(1);"
"var a = 5";
const char* warmup = "a = f()";
@@ -845,10 +844,10 @@
// Running the warmup script has effect on whether functions are
// pre-compiled, but does not pollute the context.
CHECK(IsCompiled("f"));
- CHECK(IsCompiled("Math.sin"));
+ CHECK(IsCompiled("Math.sinh"));
CHECK(!IsCompiled("g"));
- CHECK(!IsCompiled("Math.cos"));
- CHECK(!IsCompiled("Math.tan"));
+ CHECK(!IsCompiled("Math.cosh"));
+ CHECK(!IsCompiled("Math.tanh"));
CHECK_EQ(5, CompileRun("a")->Int32Value(context).FromJust());
}
isolate->Dispose();
@@ -1827,12 +1826,302 @@
false);
delete script_data;
- SimulateIncrementalMarking(isolate->heap());
+ heap::SimulateIncrementalMarking(isolate->heap());
script_data = CodeSerializer::Serialize(isolate, shared, source);
delete script_data;
}
+#if V8_TARGET_ARCH_X64
+TEST(CodeSerializerCell) {
+ FLAG_serialize_toplevel = true;
+ LocalContext context;
+ Isolate* isolate = CcTest::i_isolate();
+ isolate->compilation_cache()->Disable(); // Disable same-isolate code cache.
+
+ v8::HandleScope scope(CcTest::isolate());
+
+ size_t actual_size;
+ byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
+ Assembler::kMinimalBufferSize, &actual_size, true));
+ CHECK(buffer);
+ HandleScope handles(isolate);
+
+ MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size),
+ v8::internal::CodeObjectRequired::kYes);
+ assembler.enable_serializer();
+ Handle<HeapNumber> number = isolate->factory()->NewHeapNumber(0.3);
+ CHECK(isolate->heap()->InNewSpace(*number));
+ MacroAssembler* masm = &assembler;
+ masm->MoveHeapObject(rax, number);
+ masm->ret(0);
+ CodeDesc desc;
+ masm->GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::FUNCTION), masm->CodeObject());
+ code->set_has_reloc_info_for_serialization(true);
+
+ RelocIterator rit1(*code, 1 << RelocInfo::CELL);
+ CHECK_EQ(*number, rit1.rinfo()->target_cell()->value());
+
+ Handle<String> source = isolate->factory()->empty_string();
+ Handle<SharedFunctionInfo> sfi =
+ isolate->factory()->NewSharedFunctionInfo(source, code, false);
+ ScriptData* script_data = CodeSerializer::Serialize(isolate, sfi, source);
+
+ Handle<SharedFunctionInfo> copy =
+ CodeSerializer::Deserialize(isolate, script_data, source)
+ .ToHandleChecked();
+ RelocIterator rit2(copy->code(), 1 << RelocInfo::CELL);
+ CHECK(rit2.rinfo()->target_cell()->IsCell());
+ Handle<Cell> cell(rit2.rinfo()->target_cell());
+ CHECK(cell->value()->IsHeapNumber());
+ CHECK_EQ(0.3, HeapNumber::cast(cell->value())->value());
+
+ delete script_data;
+}
+#endif // V8_TARGET_ARCH_X64
+
+TEST(SnapshotCreatorMultipleContexts) {
+ DisableTurbofan();
+ v8::StartupData blob;
+ {
+ v8::SnapshotCreator creator;
+ v8::Isolate* isolate = creator.GetIsolate();
+ {
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+ CompileRun("var f = function() { return 1; }");
+ CHECK_EQ(0, creator.AddContext(context));
+ }
+ {
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+ CompileRun("var f = function() { return 2; }");
+ CHECK_EQ(1, creator.AddContext(context));
+ }
+ {
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ CHECK_EQ(2, creator.AddContext(context));
+ }
+ blob =
+ creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
+ }
+
+ v8::Isolate::CreateParams params;
+ params.snapshot_blob = &blob;
+ params.array_buffer_allocator = CcTest::array_buffer_allocator();
+ v8::Isolate* isolate = v8::Isolate::New(params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::ExtensionConfiguration* no_extension = nullptr;
+ v8::Local<v8::ObjectTemplate> no_template = v8::Local<v8::ObjectTemplate>();
+ v8::Local<v8::Value> no_object = v8::Local<v8::Value>();
+ {
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context =
+ v8::Context::New(isolate, no_extension, no_template, no_object, 0);
+ v8::Context::Scope context_scope(context);
+ ExpectInt32("f()", 1);
+ }
+ {
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context =
+ v8::Context::New(isolate, no_extension, no_template, no_object, 1);
+ v8::Context::Scope context_scope(context);
+ ExpectInt32("f()", 2);
+ }
+ {
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context =
+ v8::Context::New(isolate, no_extension, no_template, no_object, 2);
+ v8::Context::Scope context_scope(context);
+ ExpectUndefined("this.f");
+ }
+ }
+
+ isolate->Dispose();
+ delete[] blob.data;
+}
+
+static void SerializedCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& args) {
+ args.GetReturnValue().Set(v8_num(42));
+}
+
+static void SerializedCallbackReplacement(
+ const v8::FunctionCallbackInfo<v8::Value>& args) {
+ args.GetReturnValue().Set(v8_num(1337));
+}
+
+intptr_t original_external_references[] = {
+ reinterpret_cast<intptr_t>(SerializedCallback), 0};
+
+intptr_t replaced_external_references[] = {
+ reinterpret_cast<intptr_t>(SerializedCallbackReplacement), 0};
+
+TEST(SnapshotCreatorExternalReferences) {
+ DisableTurbofan();
+ v8::StartupData blob;
+ {
+ v8::SnapshotCreator creator(original_external_references);
+ v8::Isolate* isolate = creator.GetIsolate();
+ {
+ v8::HandleScope handle_scope(isolate);
+ v8::Local<v8::Context> context = v8::Context::New(isolate);
+ v8::Context::Scope context_scope(context);
+ v8::Local<v8::FunctionTemplate> callback =
+ v8::FunctionTemplate::New(isolate, SerializedCallback);
+ v8::Local<v8::Value> function =
+ callback->GetFunction(context).ToLocalChecked();
+ CHECK(context->Global()->Set(context, v8_str("f"), function).FromJust());
+ ExpectInt32("f()", 42);
+ CHECK_EQ(0, creator.AddContext(context));
+ }
+ blob =
+ creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
+ }
+
+ // Deserialize with the original external reference.
+ {
+ v8::Isolate::CreateParams params;
+ params.snapshot_blob = &blob;
+ params.array_buffer_allocator = CcTest::array_buffer_allocator();
+ params.external_references = original_external_references;
+ v8::Isolate* isolate = v8::Isolate::New(params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::ExtensionConfiguration* no_extension = nullptr;
+ v8::Local<v8::ObjectTemplate> no_template =
+ v8::Local<v8::ObjectTemplate>();
+ v8::Local<v8::Value> no_object = v8::Local<v8::Value>();
+ v8::Local<v8::Context> context =
+ v8::Context::New(isolate, no_extension, no_template, no_object, 0);
+ v8::Context::Scope context_scope(context);
+ ExpectInt32("f()", 42);
+ }
+ isolate->Dispose();
+ }
+
+ // Deserialize with the some other external reference.
+ {
+ v8::Isolate::CreateParams params;
+ params.snapshot_blob = &blob;
+ params.array_buffer_allocator = CcTest::array_buffer_allocator();
+ params.external_references = replaced_external_references;
+ v8::Isolate* isolate = v8::Isolate::New(params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::ExtensionConfiguration* no_extension = nullptr;
+ v8::Local<v8::ObjectTemplate> no_template =
+ v8::Local<v8::ObjectTemplate>();
+ v8::Local<v8::Value> no_object = v8::Local<v8::Value>();
+ v8::Local<v8::Context> context =
+ v8::Context::New(isolate, no_extension, no_template, no_object, 0);
+ v8::Context::Scope context_scope(context);
+ ExpectInt32("f()", 1337);
+ }
+ isolate->Dispose();
+ }
+ delete[] blob.data;
+}
+
+TEST(SnapshotCreatorTemplates) {
+ DisableTurbofan();
+ v8::StartupData blob;
+ {
+ v8::SnapshotCreator creator(original_external_references);
+ v8::Isolate* isolate = creator.GetIsolate();
+ {
+ v8::HandleScope handle_scope(isolate);
+ v8::ExtensionConfiguration* no_extension = nullptr;
+ v8::Local<v8::ObjectTemplate> global_template =
+ v8::ObjectTemplate::New(isolate);
+ v8::Local<v8::FunctionTemplate> callback =
+ v8::FunctionTemplate::New(isolate, SerializedCallback);
+ global_template->Set(v8_str("f"), callback);
+ v8::Local<v8::Context> context =
+ v8::Context::New(isolate, no_extension, global_template);
+ v8::Context::Scope context_scope(context);
+ ExpectInt32("f()", 42);
+ CHECK_EQ(0, creator.AddContext(context));
+ CHECK_EQ(0, creator.AddTemplate(callback));
+ CHECK_EQ(1, creator.AddTemplate(global_template));
+ }
+ blob =
+ creator.CreateBlob(v8::SnapshotCreator::FunctionCodeHandling::kClear);
+ }
+
+ {
+ v8::Isolate::CreateParams params;
+ params.snapshot_blob = &blob;
+ params.array_buffer_allocator = CcTest::array_buffer_allocator();
+ params.external_references = original_external_references;
+ v8::Isolate* isolate = v8::Isolate::New(params);
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ {
+ // Create a new context without a new object template.
+ v8::HandleScope handle_scope(isolate);
+ v8::ExtensionConfiguration* no_extension = nullptr;
+ v8::Local<v8::ObjectTemplate> no_template =
+ v8::Local<v8::ObjectTemplate>();
+ v8::Local<v8::Value> no_object = v8::Local<v8::Value>();
+ v8::Local<v8::Context> context =
+ v8::Context::New(isolate, no_extension, no_template, no_object, 0);
+ v8::Context::Scope context_scope(context);
+ ExpectInt32("f()", 42);
+
+ // Retrieve the snapshotted object template.
+ v8::Local<v8::ObjectTemplate> obj_template =
+ v8::ObjectTemplate::FromSnapshot(isolate, 1);
+ CHECK(!obj_template.IsEmpty());
+ v8::Local<v8::Object> object =
+ obj_template->NewInstance(context).ToLocalChecked();
+ CHECK(context->Global()->Set(context, v8_str("o"), object).FromJust());
+ ExpectInt32("o.f()", 42);
+ // Check that it instantiates to the same prototype.
+ ExpectTrue("o.f.prototype === f.prototype");
+
+ // Retrieve the snapshotted function template.
+ v8::Local<v8::FunctionTemplate> fun_template =
+ v8::FunctionTemplate::FromSnapshot(isolate, 0);
+ CHECK(!fun_template.IsEmpty());
+ v8::Local<v8::Function> fun =
+ fun_template->GetFunction(context).ToLocalChecked();
+ CHECK(context->Global()->Set(context, v8_str("g"), fun).FromJust());
+ ExpectInt32("g()", 42);
+ // Check that it instantiates to the same prototype.
+ ExpectTrue("g.prototype === f.prototype");
+ }
+
+ {
+ // Create a context with a new object template. It is merged into the
+ // deserialized global object.
+ v8::HandleScope handle_scope(isolate);
+ v8::ExtensionConfiguration* no_extension = nullptr;
+ v8::Local<v8::ObjectTemplate> global_template =
+ v8::ObjectTemplate::New(isolate);
+ global_template->Set(
+ v8_str("g"),
+ v8::FunctionTemplate::New(isolate, SerializedCallbackReplacement));
+ v8::Local<v8::Value> no_object = v8::Local<v8::Value>();
+ v8::Local<v8::Context> context = v8::Context::New(
+ isolate, no_extension, global_template, no_object, 0);
+ v8::Context::Scope context_scope(context);
+ ExpectInt32("g()", 1337);
+ ExpectInt32("f()", 42);
+ }
+ }
+ isolate->Dispose();
+ }
+ delete[] blob.data;
+}
TEST(SerializationMemoryStats) {
FLAG_profile_deserialization = true;
diff --git a/test/cctest/test-slots-buffer.cc b/test/cctest/test-slots-buffer.cc
index 07b70f5..4b8aeb7 100644
--- a/test/cctest/test-slots-buffer.cc
+++ b/test/cctest/test-slots-buffer.cc
@@ -4,7 +4,7 @@
#include "src/heap/slots-buffer.h"
#include "test/cctest/cctest.h"
-#include "test/cctest/heap/utils-inl.h"
+#include "test/cctest/heap/heap-utils.h"
namespace v8 {
namespace internal {
@@ -101,7 +101,7 @@
// Write an old space reference into field 4 which points to an object on an
// evacuation candidate.
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
Handle<FixedArray> valid_object =
isolate->factory()->NewFixedArray(23, TENURED);
Page* page = Page::FromAddress(valid_object->address());
diff --git a/test/cctest/test-strings.cc b/test/cctest/test-strings.cc
index 770042d..afa8ecb 100644
--- a/test/cctest/test-strings.cc
+++ b/test/cctest/test-strings.cc
@@ -1110,7 +1110,8 @@
.ToLocalChecked()
->Run(context)
.ToLocalChecked();
- CHECK_EQ(results[i]->IsUndefined(), result->IsUndefined());
+ CHECK_EQ(results[i]->IsUndefined(CcTest::i_isolate()),
+ result->IsUndefined());
CHECK_EQ(results[i]->IsNumber(), result->IsNumber());
if (result->IsNumber()) {
int32_t value = 0;
diff --git a/test/cctest/test-thread-termination.cc b/test/cctest/test-thread-termination.cc
index 85dfd13..9d3cbf6 100644
--- a/test/cctest/test-thread-termination.cc
+++ b/test/cctest/test-thread-termination.cc
@@ -204,6 +204,31 @@
semaphore = NULL;
}
+// Test that execution can be terminated from within JSON.stringify.
+TEST(TerminateJsonStringify) {
+ semaphore = new v8::base::Semaphore(0);
+ TerminatorThread thread(CcTest::i_isolate());
+ thread.Start();
+
+ v8::HandleScope scope(CcTest::isolate());
+ v8::Local<v8::ObjectTemplate> global =
+ CreateGlobalTemplate(CcTest::isolate(), Signal, DoLoop);
+ v8::Local<v8::Context> context =
+ v8::Context::New(CcTest::isolate(), NULL, global);
+ v8::Context::Scope context_scope(context);
+ CHECK(!CcTest::isolate()->IsExecutionTerminating());
+ v8::MaybeLocal<v8::Value> result =
+ CompileRun(CcTest::isolate()->GetCurrentContext(),
+ "var x = [];"
+ "x[2**31]=1;"
+ "terminate();"
+ "JSON.stringify(x);"
+ "fail();");
+ CHECK(result.IsEmpty());
+ thread.Join();
+ delete semaphore;
+ semaphore = NULL;
+}
int call_count = 0;
diff --git a/test/cctest/test-unboxed-doubles.cc b/test/cctest/test-unboxed-doubles.cc
index 39f8fbf..c8a8bbb 100644
--- a/test/cctest/test-unboxed-doubles.cc
+++ b/test/cctest/test-unboxed-doubles.cc
@@ -15,7 +15,7 @@
#include "src/ic/ic.h"
#include "src/macro-assembler.h"
#include "test/cctest/cctest.h"
-#include "test/cctest/heap/utils-inl.h"
+#include "test/cctest/heap/heap-utils.h"
using namespace v8::base;
using namespace v8::internal;
@@ -1112,7 +1112,7 @@
{
AlwaysAllocateScope always_allocate(isolate);
// Make sure |obj_value| is placed on an old-space evacuation candidate.
- SimulateFullSpace(old_space);
+ heap::SimulateFullSpace(old_space);
obj_value = factory->NewJSArray(32 * KB, FAST_HOLEY_ELEMENTS, TENURED);
ec_page = Page::FromAddress(obj_value->address());
}
@@ -1142,7 +1142,7 @@
FLAG_stress_compaction = true;
FLAG_manual_evacuation_candidates_selection = true;
ec_page->SetFlag(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
// Disable stress compaction mode in order to let GC do scavenge.
FLAG_stress_compaction = false;
@@ -1451,7 +1451,7 @@
CHECK(old_space->Contains(*obj));
// Make sure |obj_value| is placed on an old-space evacuation candidate.
- SimulateFullSpace(old_space);
+ heap::SimulateFullSpace(old_space);
obj_value = factory->NewJSArray(32 * KB, FAST_HOLEY_ELEMENTS, TENURED);
ec_page = Page::FromAddress(obj_value->address());
CHECK_NE(ec_page, Page::FromAddress(obj->address()));
@@ -1460,7 +1460,7 @@
// Heap is ready, force |ec_page| to become an evacuation candidate and
// simulate incremental marking.
ec_page->SetFlag(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
// Check that everything is ready for triggering incremental write barrier
// (i.e. that both |obj| and |obj_value| are black and the marking phase is
diff --git a/test/cctest/test-usecounters.cc b/test/cctest/test-usecounters.cc
new file mode 100644
index 0000000..8d4628c
--- /dev/null
+++ b/test/cctest/test-usecounters.cc
@@ -0,0 +1,73 @@
+// 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/v8.h"
+
+#include "test/cctest/cctest.h"
+
+namespace {
+
+int* global_use_counts = NULL;
+
+void MockUseCounterCallback(v8::Isolate* isolate,
+ v8::Isolate::UseCounterFeature feature) {
+ ++global_use_counts[feature];
+}
+}
+
+TEST(DefineGetterSetterThrowUseCount) {
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope scope(isolate);
+ LocalContext env;
+ int use_counts[v8::Isolate::kUseCounterFeatureCount] = {};
+ global_use_counts = use_counts;
+ CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
+
+ // __defineGetter__ and __defineSetter__ do not increment
+ // kDefineGetterOrSetterWouldThrow on success
+ CompileRun(
+ "var a = {};"
+ "Object.defineProperty(a, 'b', { value: 0, configurable: true });"
+ "a.__defineGetter__('b', ()=>{});");
+ CHECK_EQ(0, use_counts[v8::Isolate::kDefineGetterOrSetterWouldThrow]);
+ CompileRun(
+ "var a = {};"
+ "Object.defineProperty(a, 'b', { value: 0, configurable: true });"
+ "a.__defineSetter__('b', ()=>{});");
+ CHECK_EQ(0, use_counts[v8::Isolate::kDefineGetterOrSetterWouldThrow]);
+
+ // __defineGetter__ and __defineSetter__ do not increment
+ // kDefineGetterOrSetterWouldThrow on other errors
+ v8::Local<v8::Value> resultProxyThrow = CompileRun(
+ "var exception;"
+ "try {"
+ "var a = new Proxy({}, { defineProperty: ()=>{throw new Error;} });"
+ "a.__defineGetter__('b', ()=>{});"
+ "} catch (e) { exception = e; }"
+ "exception");
+ CHECK_EQ(0, use_counts[v8::Isolate::kDefineGetterOrSetterWouldThrow]);
+ CHECK(resultProxyThrow->IsObject());
+ resultProxyThrow = CompileRun(
+ "var exception;"
+ "try {"
+ "var a = new Proxy({}, { defineProperty: ()=>{throw new Error;} });"
+ "a.__defineSetter__('b', ()=>{});"
+ "} catch (e) { exception = e; }"
+ "exception");
+ CHECK_EQ(0, use_counts[v8::Isolate::kDefineGetterOrSetterWouldThrow]);
+ CHECK(resultProxyThrow->IsObject());
+
+ // __defineGetter__ and __defineSetter__ increment
+ // kDefineGetterOrSetterWouldThrow when they would throw per spec (B.2.2.2)
+ CompileRun(
+ "var a = {};"
+ "Object.defineProperty(a, 'b', { value: 0, configurable: false });"
+ "a.__defineGetter__('b', ()=>{});");
+ CHECK_EQ(1, use_counts[v8::Isolate::kDefineGetterOrSetterWouldThrow]);
+ CompileRun(
+ "var a = {};"
+ "Object.defineProperty(a, 'b', { value: 0, configurable: false });"
+ "a.__defineSetter__('b', ()=>{});");
+ CHECK_EQ(2, use_counts[v8::Isolate::kDefineGetterOrSetterWouldThrow]);
+}
diff --git a/test/cctest/test-weakmaps.cc b/test/cctest/test-weakmaps.cc
index 829f320..2d0e620 100644
--- a/test/cctest/test-weakmaps.cc
+++ b/test/cctest/test-weakmaps.cc
@@ -31,7 +31,7 @@
#include "src/global-handles.h"
#include "test/cctest/cctest.h"
-#include "test/cctest/heap/utils-inl.h"
+#include "test/cctest/heap/heap-utils.h"
using namespace v8::internal;
@@ -177,7 +177,7 @@
// Start second old-space page so that values land on evacuation candidate.
Page* first_page = heap->old_space()->anchor()->next_page();
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
// Fill up weak map with values on an evacuation candidate.
{
@@ -216,7 +216,7 @@
// Start second old-space page so that keys land on evacuation candidate.
Page* first_page = heap->old_space()->anchor()->next_page();
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
// Fill up weak map with keys on an evacuation candidate.
Handle<JSObject> keys[32];
@@ -249,7 +249,7 @@
{
HandleScope scope(isolate);
AllocateJSWeakMap(isolate);
- SimulateIncrementalMarking(heap);
+ heap::SimulateIncrementalMarking(heap);
}
// The weak map is marked black here but leaving the handle scope will make
// the object unreachable. Aborting incremental marking will clear all the
diff --git a/test/cctest/test-weaksets.cc b/test/cctest/test-weaksets.cc
index 53a5913..ec6945a 100644
--- a/test/cctest/test-weaksets.cc
+++ b/test/cctest/test-weaksets.cc
@@ -31,7 +31,7 @@
#include "src/global-handles.h"
#include "test/cctest/cctest.h"
-#include "test/cctest/heap/utils-inl.h"
+#include "test/cctest/heap/heap-utils.h"
using namespace v8::internal;
@@ -176,7 +176,7 @@
// Start second old-space page so that values land on evacuation candidate.
Page* first_page = heap->old_space()->anchor()->next_page();
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
// Fill up weak set with values on an evacuation candidate.
{
@@ -215,7 +215,7 @@
// Start second old-space page so that keys land on evacuation candidate.
Page* first_page = heap->old_space()->anchor()->next_page();
- SimulateFullSpace(heap->old_space());
+ heap::SimulateFullSpace(heap->old_space());
// Fill up weak set with keys on an evacuation candidate.
Handle<JSObject> keys[32];
diff --git a/test/cctest/trace-extension.cc b/test/cctest/trace-extension.cc
index 6eb81b2..19f8cd8 100644
--- a/test/cctest/trace-extension.cc
+++ b/test/cctest/trace-extension.cc
@@ -86,7 +86,7 @@
#else
#error Host architecture is neither 32-bit nor 64-bit.
#endif
- printf("Trace: %p\n", fp);
+ printf("Trace: %p\n", static_cast<void*>(fp));
return fp;
}
diff --git a/test/cctest/types-fuzz.h b/test/cctest/types-fuzz.h
index 79e4608..7bf9700 100644
--- a/test/cctest/types-fuzz.h
+++ b/test/cctest/types-fuzz.h
@@ -208,8 +208,6 @@
Type* Representation(Type* t) { return Type::Representation(t, zone_); }
- // Type* Semantic(Type* t) { return Intersect(t,
- // MaskSemanticForTesting); }
Type* Semantic(Type* t) { return Type::Semantic(t, zone_); }
Type* Random() {
diff --git a/test/cctest/wasm/test-run-wasm-64.cc b/test/cctest/wasm/test-run-wasm-64.cc
index 333183a..af87498 100644
--- a/test/cctest/wasm/test-run-wasm-64.cc
+++ b/test/cctest/wasm/test-run-wasm-64.cc
@@ -14,6 +14,13 @@
#include "test/cctest/wasm/test-signatures.h"
#include "test/cctest/wasm/wasm-run-utils.h"
+// If the target architecture is 64-bit, enable all tests.
+#if !V8_TARGET_ARCH_32_BIT || V8_TARGET_ARCH_X64
+#define WASM_64 1
+#else
+#define WASM_64 0
+#endif
+
#define CHECK_TRAP32(x) \
CHECK_EQ(0xdeadbeef, (bit_cast<uint32_t>(x)) & 0xFFFFFFFF)
#define CHECK_TRAP64(x) \
@@ -92,7 +99,7 @@
WASM_EXEC_TEST(I64Const) {
REQUIRE(I64Const);
- WasmRunner<int64_t> r;
+ WasmRunner<int64_t> r(execution_mode);
const int64_t kExpectedValue = 0x1122334455667788LL;
// return(kExpectedValue)
BUILD(r, WASM_I64V_9(kExpectedValue));
@@ -103,7 +110,7 @@
REQUIRE(I64Const);
int cntr = 0;
FOR_INT32_INPUTS(i) {
- WasmRunner<int64_t> r;
+ WasmRunner<int64_t> r(execution_mode);
const int64_t kExpectedValue = (static_cast<int64_t>(*i) << 32) | cntr;
// return(kExpectedValue)
BUILD(r, WASM_I64V(kExpectedValue));
@@ -114,7 +121,7 @@
WASM_EXEC_TEST(Return_I64) {
REQUIRE(I64Return);
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_RETURN1(WASM_GET_LOCAL(0)));
@@ -123,7 +130,8 @@
WASM_EXEC_TEST(I64Add) {
REQUIRE(I64Add);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ(*i + *j, r.Call(*i, *j)); }
@@ -132,7 +140,8 @@
WASM_EXEC_TEST(I64Sub) {
REQUIRE(I64Sub);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ(*i - *j, r.Call(*i, *j)); }
@@ -141,7 +150,8 @@
WASM_EXEC_TEST(I64DivS) {
REQUIRE(I64DivS);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) {
@@ -158,7 +168,8 @@
WASM_EXEC_TEST(I64DivS_Trap) {
REQUIRE(I64DivS);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(0, r.Call(asi64(0), asi64(100)));
CHECK_TRAP64(r.Call(asi64(100), asi64(0)));
@@ -170,7 +181,7 @@
WASM_EXEC_TEST(I64DivS_Byzero_Const) {
REQUIRE(I64DivS);
for (int8_t denom = -2; denom < 8; denom++) {
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64V_1(denom)));
for (int64_t val = -7; val < 8; val++) {
if (denom == 0) {
@@ -184,7 +195,8 @@
WASM_EXEC_TEST(I64DivU) {
REQUIRE(I64DivU);
- WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+ MachineType::Uint64());
BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) {
@@ -199,7 +211,8 @@
WASM_EXEC_TEST(I64DivU_Trap) {
REQUIRE(I64DivU);
- WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+ MachineType::Uint64());
BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(0, r.Call(asu64(0), asu64(100)));
CHECK_TRAP64(r.Call(asu64(100), asu64(0)));
@@ -210,7 +223,7 @@
WASM_EXEC_TEST(I64DivU_Byzero_Const) {
REQUIRE(I64DivU);
for (uint64_t denom = 0xfffffffffffffffe; denom < 8; denom++) {
- WasmRunner<uint64_t> r(MachineType::Uint64());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64());
BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64V_1(denom)));
for (uint64_t val = 0xfffffffffffffff0; val < 8; val++) {
@@ -225,7 +238,8 @@
WASM_EXEC_TEST(I64RemS) {
REQUIRE(I64RemS);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) {
@@ -240,7 +254,8 @@
WASM_EXEC_TEST(I64RemS_Trap) {
REQUIRE(I64RemS);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(33, r.Call(asi64(133), asi64(100)));
CHECK_EQ(0, r.Call(std::numeric_limits<int64_t>::min(), asi64(-1)));
@@ -251,7 +266,8 @@
WASM_EXEC_TEST(I64RemU) {
REQUIRE(I64RemU);
- WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+ MachineType::Uint64());
BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) {
@@ -266,7 +282,8 @@
WASM_EXEC_TEST(I64RemU_Trap) {
REQUIRE(I64RemU);
- WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+ MachineType::Uint64());
BUILD(r, WASM_I64_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(17, r.Call(asu64(217), asu64(100)));
CHECK_TRAP64(r.Call(asu64(100), asu64(0)));
@@ -276,7 +293,8 @@
WASM_EXEC_TEST(I64And) {
REQUIRE(I64And);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ((*i) & (*j), r.Call(*i, *j)); }
@@ -285,7 +303,8 @@
WASM_EXEC_TEST(I64Ior) {
REQUIRE(I64Ior);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_IOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ((*i) | (*j), r.Call(*i, *j)); }
@@ -294,7 +313,8 @@
WASM_EXEC_TEST(I64Xor) {
REQUIRE(I64Xor);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ((*i) ^ (*j), r.Call(*i, *j)); }
@@ -304,7 +324,8 @@
WASM_EXEC_TEST(I64Shl) {
REQUIRE(I64Shl);
{
- WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+ MachineType::Uint64());
BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT64_INPUTS(i) {
@@ -315,22 +336,22 @@
}
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 0, r.Call(*i)); }
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(32)));
FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 32, r.Call(*i)); }
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(20)));
FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 20, r.Call(*i)); }
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(40)));
FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 40, r.Call(*i)); }
}
@@ -339,7 +360,8 @@
WASM_EXEC_TEST(I64ShrU) {
REQUIRE(I64ShrU);
{
- WasmRunner<uint64_t> r(MachineType::Uint64(), MachineType::Uint64());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
+ MachineType::Uint64());
BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT64_INPUTS(i) {
@@ -350,22 +372,22 @@
}
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); }
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(32)));
FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); }
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(20)));
FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); }
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(40)));
FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); }
}
@@ -374,7 +396,8 @@
WASM_EXEC_TEST(I64ShrS) {
REQUIRE(I64ShrS);
{
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
@@ -385,22 +408,22 @@
}
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); }
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(32)));
FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); }
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(20)));
FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); }
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_I64V_1(40)));
FOR_INT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); }
}
@@ -408,7 +431,8 @@
WASM_EXEC_TEST(I64Eq) {
REQUIRE(I64Eq);
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_EQ(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ(*i == *j ? 1 : 0, r.Call(*i, *j)); }
@@ -417,7 +441,8 @@
WASM_EXEC_TEST(I64Ne) {
REQUIRE(I64Ne);
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_NE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ(*i != *j ? 1 : 0, r.Call(*i, *j)); }
@@ -426,7 +451,8 @@
WASM_EXEC_TEST(I64LtS) {
REQUIRE(I64LtS);
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_LTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ(*i < *j ? 1 : 0, r.Call(*i, *j)); }
@@ -435,7 +461,8 @@
WASM_EXEC_TEST(I64LeS) {
REQUIRE(I64LeS);
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_LES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ(*i <= *j ? 1 : 0, r.Call(*i, *j)); }
@@ -444,7 +471,8 @@
WASM_EXEC_TEST(I64LtU) {
REQUIRE(I64LtU);
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_LTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) { CHECK_EQ(*i < *j ? 1 : 0, r.Call(*i, *j)); }
@@ -453,7 +481,8 @@
WASM_EXEC_TEST(I64LeU) {
REQUIRE(I64LeU);
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_LEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) { CHECK_EQ(*i <= *j ? 1 : 0, r.Call(*i, *j)); }
@@ -462,7 +491,8 @@
WASM_EXEC_TEST(I64GtS) {
REQUIRE(I64GtS);
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_GTS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ(*i > *j ? 1 : 0, r.Call(*i, *j)); }
@@ -471,7 +501,8 @@
WASM_EXEC_TEST(I64GeS) {
REQUIRE(I64GeS);
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_GES(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ(*i >= *j ? 1 : 0, r.Call(*i, *j)); }
@@ -480,7 +511,8 @@
WASM_EXEC_TEST(I64GtU) {
REQUIRE(I64GtU);
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_GTU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) { CHECK_EQ(*i > *j ? 1 : 0, r.Call(*i, *j)); }
@@ -489,7 +521,8 @@
WASM_EXEC_TEST(I64GeU) {
REQUIRE(I64GeU);
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_GEU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT64_INPUTS(i) {
FOR_UINT64_INPUTS(j) { CHECK_EQ(*i >= *j ? 1 : 0, r.Call(*i, *j)); }
@@ -499,7 +532,7 @@
WASM_EXEC_TEST(I32ConvertI64) {
REQUIRE(I32ConvertI64);
FOR_INT64_INPUTS(i) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
BUILD(r, WASM_I32_CONVERT_I64(WASM_I64V(*i)));
CHECK_EQ(static_cast<int32_t>(*i), r.Call());
}
@@ -507,14 +540,14 @@
WASM_EXEC_TEST(I64SConvertI32) {
REQUIRE(I64SConvertI32);
- WasmRunner<int64_t> r(MachineType::Int32());
+ WasmRunner<int64_t> r(execution_mode, 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)); }
}
WASM_EXEC_TEST(I64UConvertI32) {
REQUIRE(I64UConvertI32);
- WasmRunner<int64_t> r(MachineType::Uint32());
+ WasmRunner<int64_t> r(execution_mode, 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)); }
}
@@ -529,7 +562,7 @@
{26, 0x1123456782345678},
{38, 0xffedcba09edcba09}};
- WasmRunner<int64_t> r(MachineType::Uint64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Uint64());
BUILD(r, WASM_I64_POPCNT(WASM_GET_LOCAL(0)));
for (size_t i = 0; i < arraysize(values); i++) {
CHECK_EQ(values[i].expected, r.Call(values[i].input));
@@ -538,7 +571,7 @@
WASM_EXEC_TEST(F32SConvertI64) {
REQUIRE(F32SConvertI64);
- WasmRunner<float> r(MachineType::Int64());
+ WasmRunner<float> r(execution_mode, 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)); }
}
@@ -624,7 +657,7 @@
{0x8000008000000001, 0x5f000001},
{0x8000000000000400, 0x5f000000},
{0x8000000000000401, 0x5f000000}};
- WasmRunner<float> r(MachineType::Uint64());
+ WasmRunner<float> r(execution_mode, MachineType::Uint64());
BUILD(r, WASM_F32_UCONVERT_I64(WASM_GET_LOCAL(0)));
for (size_t i = 0; i < arraysize(values); i++) {
CHECK_EQ(bit_cast<float>(values[i].expected), r.Call(values[i].input));
@@ -633,7 +666,7 @@
WASM_EXEC_TEST(F64SConvertI64) {
REQUIRE(F64SConvertI64);
- WasmRunner<double> r(MachineType::Int64());
+ WasmRunner<double> r(execution_mode, 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)); }
}
@@ -718,7 +751,7 @@
{0x8000008000000001, 0x43e0000010000000},
{0x8000000000000400, 0x43e0000000000000},
{0x8000000000000401, 0x43e0000000000001}};
- WasmRunner<double> r(MachineType::Uint64());
+ WasmRunner<double> r(execution_mode, MachineType::Uint64());
BUILD(r, WASM_F64_UCONVERT_I64(WASM_GET_LOCAL(0)));
for (size_t i = 0; i < arraysize(values); i++) {
CHECK_EQ(bit_cast<double>(values[i].expected), r.Call(values[i].input));
@@ -726,7 +759,7 @@
}
WASM_EXEC_TEST(I64SConvertF32a) {
- WasmRunner<int64_t> r(MachineType::Float32());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -740,7 +773,7 @@
}
WASM_EXEC_TEST(I64SConvertF64a) {
- WasmRunner<int64_t> r(MachineType::Float64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -754,7 +787,7 @@
}
WASM_EXEC_TEST(I64UConvertF32a) {
- WasmRunner<uint64_t> r(MachineType::Float32());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -768,7 +801,7 @@
}
WASM_EXEC_TEST(I64UConvertF64a) {
- WasmRunner<uint64_t> r(MachineType::Float64());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -789,7 +822,7 @@
param_types[4] = kAstI32;
FunctionSig sig(1, 19, param_types);
for (int i = 0; i < 19; i++) {
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t(&sig, &module);
if (i == 2 || i == 3) {
continue;
@@ -819,40 +852,44 @@
}
}
-void TestI64Binop(WasmOpcode opcode, int64_t expected, int64_t a, int64_t b) {
+void TestI64Binop(WasmExecutionMode execution_mode, WasmOpcode opcode,
+ int64_t expected, int64_t a, int64_t b) {
{
- WasmRunner<int64_t> r;
+ WasmRunner<int64_t> r(execution_mode);
// return K op K
BUILD(r, WASM_BINOP(opcode, WASM_I64V(a), WASM_I64V(b)));
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
// return a op b
BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(expected, r.Call(a, b));
}
}
-void TestI64Cmp(WasmOpcode opcode, int64_t expected, int64_t a, int64_t b) {
+void TestI64Cmp(WasmExecutionMode execution_mode, WasmOpcode opcode,
+ int64_t expected, int64_t a, int64_t b) {
{
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// return K op K
BUILD(r, WASM_BINOP(opcode, WASM_I64V(a), WASM_I64V(b)));
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
// return a op b
BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(expected, r.Call(a, b));
}
}
-#define TEST_I64_BINOP(name, expected, a, b) \
- do { \
- if (WASM_64 || kSupported_##name) \
- TestI64Binop(kExpr##name, expected, a, b); \
+#define TEST_I64_BINOP(name, expected, a, b) \
+ do { \
+ if (WASM_64 || kSupported_##name) \
+ TestI64Binop(execution_mode, kExpr##name, expected, a, b); \
} while (false)
WASM_EXEC_TEST(I64Binops) {
@@ -887,9 +924,10 @@
TEST_I64_BINOP(I64Rol, 8728493013947314237, 0xe07af243ac4d219d, 15);
}
-#define TEST_I64_CMP(name, expected, a, b) \
- do { \
- if (WASM_64 || kSupported_##name) TestI64Cmp(kExpr##name, expected, a, b); \
+#define TEST_I64_CMP(name, expected, a, b) \
+ do { \
+ if (WASM_64 || kSupported_##name) \
+ TestI64Cmp(execution_mode, kExpr##name, expected, a, b); \
} while (false)
WASM_EXEC_TEST(I64Compare) {
@@ -944,7 +982,7 @@
{62, 0x0000000000000002}, {63, 0x0000000000000001},
{64, 0x0000000000000000}};
- WasmRunner<int64_t> r(MachineType::Uint64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Uint64());
BUILD(r, WASM_I64_CLZ(WASM_GET_LOCAL(0)));
for (size_t i = 0; i < arraysize(values); i++) {
CHECK_EQ(values[i].expected, r.Call(values[i].input));
@@ -990,7 +1028,7 @@
{2, 0x000000009afdbc84}, {1, 0x000000009afdbc82},
{0, 0x000000009afdbc81}};
- WasmRunner<int64_t> r(MachineType::Uint64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Uint64());
BUILD(r, WASM_I64_CTZ(WASM_GET_LOCAL(0)));
for (size_t i = 0; i < arraysize(values); i++) {
CHECK_EQ(values[i].expected, r.Call(values[i].input));
@@ -1008,7 +1046,7 @@
{26, 0x1123456782345678},
{38, 0xffedcba09edcba09}};
- WasmRunner<int64_t> r(MachineType::Uint64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Uint64());
BUILD(r, WASM_I64_POPCNT(WASM_GET_LOCAL(0)));
for (size_t i = 0; i < arraysize(values); i++) {
CHECK_EQ(values[i].expected, r.Call(values[i].input));
@@ -1017,29 +1055,30 @@
// Test the WasmRunner with an Int64 return value and different numbers of
// Int64 parameters.
-TEST(Run_TestI64WasmRunner) {
+WASM_EXEC_TEST(I64WasmRunner) {
REQUIRE(I64Param);
REQUIRE(I64Xor);
- {FOR_INT64_INPUTS(i){WasmRunner<int64_t> r;
+ {FOR_INT64_INPUTS(i){WasmRunner<int64_t> r(execution_mode);
BUILD(r, WASM_I64V(*i));
CHECK_EQ(*i, r.Call());
}
}
{
- WasmRunner<int64_t> r(MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_GET_LOCAL(0));
FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
}
{
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT64_INPUTS(i) {
FOR_INT64_INPUTS(j) { CHECK_EQ(*i ^ *j, r.Call(*i, *j)); }
}
}
{
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64(),
- MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64(), MachineType::Int64());
BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0),
WASM_I64_XOR(WASM_GET_LOCAL(1), WASM_GET_LOCAL(2))));
FOR_INT64_INPUTS(i) {
@@ -1051,8 +1090,9 @@
}
}
{
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64(),
- MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64(), MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_XOR(WASM_GET_LOCAL(0),
WASM_I64_XOR(WASM_GET_LOCAL(1),
WASM_I64_XOR(WASM_GET_LOCAL(2),
@@ -1072,7 +1112,7 @@
REQUIRE(I64Sub);
// Build the target function.
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t(sigs.l_ll(), &module);
BUILD(t, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
uint32_t index = t.CompileAndAdd();
@@ -1102,7 +1142,7 @@
kExprI64LoadMem};
for (size_t m = 0; m < arraysize(loads); m++) {
- TestingModule module;
+ TestingModule module(execution_mode);
byte* memory = module.AddMemoryElems<byte>(16);
WasmRunner<int64_t> r(&module);
@@ -1138,7 +1178,7 @@
WASM_EXEC_TEST(I64SConvertF32b) {
REQUIRE(I64SConvertF32);
- WasmRunner<int64_t> r(MachineType::Float32());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -1153,7 +1193,7 @@
WASM_EXEC_TEST(I64SConvertF64b) {
REQUIRE(I64SConvertF64);
- WasmRunner<int64_t> r(MachineType::Float64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -1168,7 +1208,7 @@
WASM_EXEC_TEST(I64UConvertF32b) {
REQUIRE(I64UConvertF32);
- WasmRunner<uint64_t> r(MachineType::Float32());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_I64_UCONVERT_F32(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -1182,7 +1222,7 @@
WASM_EXEC_TEST(I64UConvertF64b) {
REQUIRE(I64UConvertF64);
- WasmRunner<uint64_t> r(MachineType::Float64());
+ WasmRunner<uint64_t> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_I64_UCONVERT_F64(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -1196,7 +1236,7 @@
WASM_EXEC_TEST(I64ReinterpretF64) {
REQUIRE(I64ReinterpretF64);
- TestingModule module;
+ TestingModule module(execution_mode);
int64_t* memory = module.AddMemoryElems<int64_t>(8);
WasmRunner<int64_t> r(&module);
@@ -1212,7 +1252,7 @@
WASM_EXEC_TEST(F64ReinterpretI64) {
REQUIRE(F64ReinterpretI64);
- TestingModule module;
+ TestingModule module(execution_mode);
int64_t* memory = module.AddMemoryElems<int64_t>(8);
WasmRunner<int64_t> r(&module, MachineType::Int64());
@@ -1230,7 +1270,7 @@
WASM_EXEC_TEST(LoadMemI64) {
REQUIRE(I64LoadStore);
- TestingModule module;
+ TestingModule module(execution_mode);
int64_t* memory = module.AddMemoryElems<int64_t>(8);
module.RandomizeMemory(1111);
WasmRunner<int64_t> r(&module);
@@ -1247,13 +1287,35 @@
CHECK_EQ(77777777, r.Call());
}
+WASM_EXEC_TEST(LoadMemI64_alignment) {
+ REQUIRE(I64LoadStore);
+ TestingModule module(execution_mode);
+ int64_t* memory = module.AddMemoryElems<int64_t>(8);
+ for (byte alignment = 0; alignment <= 3; alignment++) {
+ module.RandomizeMemory(1111);
+ WasmRunner<int64_t> r(&module);
+
+ BUILD(r,
+ WASM_LOAD_MEM_ALIGNMENT(MachineType::Int64(), WASM_I8(0), alignment));
+
+ memory[0] = 0xaabbccdd00112233LL;
+ CHECK_EQ(0xaabbccdd00112233LL, r.Call());
+
+ memory[0] = 0x33aabbccdd001122LL;
+ CHECK_EQ(0x33aabbccdd001122LL, r.Call());
+
+ memory[0] = 77777777;
+ CHECK_EQ(77777777, r.Call());
+ }
+}
+
WASM_EXEC_TEST(MemI64_Sum) {
REQUIRE(I64LoadStore);
REQUIRE(I64Add);
REQUIRE(I64Sub);
REQUIRE(I64Phi);
const int kNumElems = 20;
- TestingModule module;
+ TestingModule module(execution_mode);
uint64_t* memory = module.AddMemoryElems<uint64_t>(kNumElems);
WasmRunner<uint64_t> r(&module, MachineType::Int32());
const byte kSum = r.AllocateLocal(kAstI64);
@@ -1283,12 +1345,29 @@
}
}
+WASM_EXEC_TEST(StoreMemI64_alignment) {
+ TestingModule module(execution_mode);
+ int64_t* memory = module.AddMemoryElems<int64_t>(4);
+ const int64_t kWritten = 0x12345678abcd0011ll;
+
+ for (byte i = 0; i <= 3; i++) {
+ WasmRunner<int64_t> r(&module, MachineType::Int64());
+ BUILD(r, WASM_STORE_MEM_ALIGNMENT(MachineType::Int64(), WASM_ZERO, i,
+ WASM_GET_LOCAL(0)));
+ module.RandomizeMemory(1111);
+ memory[0] = 0;
+
+ CHECK_EQ(kWritten, r.Call(kWritten));
+ CHECK_EQ(kWritten, memory[0]);
+ }
+}
+
WASM_EXEC_TEST(I64Global) {
REQUIRE(I64LoadStore);
REQUIRE(I64SConvertI32);
REQUIRE(I64And);
REQUIRE(DepthFirst);
- TestingModule module;
+ TestingModule module(execution_mode);
int64_t* global = module.AddGlobal<int64_t>(MachineType::Int64());
WasmRunner<int32_t> r(&module, MachineType::Int32());
// global = global + p0
@@ -1308,7 +1387,7 @@
WASM_EXEC_TEST(I64Eqz) {
REQUIRE(I64Eq);
- WasmRunner<int32_t> r(MachineType::Int64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int64());
BUILD(r, WASM_I64_EQZ(WASM_GET_LOCAL(0)));
FOR_INT64_INPUTS(i) {
@@ -1319,7 +1398,8 @@
WASM_EXEC_TEST(I64Ror) {
REQUIRE(I64Ror);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_ROR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT64_INPUTS(i) {
@@ -1332,7 +1412,8 @@
WASM_EXEC_TEST(I64Rol) {
REQUIRE(I64Rol);
- WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
+ WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
+ MachineType::Int64());
BUILD(r, WASM_I64_ROL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT64_INPUTS(i) {
@@ -1342,3 +1423,153 @@
}
}
}
+
+WASM_EXEC_TEST(StoreMem_offset_oob_i64) {
+ TestingModule module(execution_mode);
+ byte* memory = module.AddMemoryElems<byte>(32);
+
+ static const MachineType machineTypes[] = {
+ MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(),
+ MachineType::Uint16(), MachineType::Int32(), MachineType::Uint32(),
+ MachineType::Int64(), MachineType::Uint64(), MachineType::Float32(),
+ MachineType::Float64()};
+
+ for (size_t m = 0; m < arraysize(machineTypes); m++) {
+ module.RandomizeMemory(1119 + static_cast<int>(m));
+ WasmRunner<int32_t> r(&module, MachineType::Uint32());
+
+ BUILD(r, WASM_STORE_MEM_OFFSET(machineTypes[m], 8, WASM_GET_LOCAL(0),
+ WASM_LOAD_MEM(machineTypes[m], WASM_ZERO)),
+ WASM_ZERO);
+
+ byte memsize = WasmOpcodes::MemSize(machineTypes[m]);
+ uint32_t boundary = 24 - memsize;
+ CHECK_EQ(0, r.Call(boundary)); // in bounds.
+ CHECK_EQ(0, memcmp(&memory[0], &memory[8 + boundary], memsize));
+
+ for (uint32_t offset = boundary + 1; offset < boundary + 19; offset++) {
+ CHECK_TRAP(r.Call(offset)); // out of bounds.
+ }
+ }
+}
+
+#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)
+
+static void CompileCallIndirectMany(LocalType param) {
+ // Make sure we don't run out of registers when compiling indirect calls
+ // with many many parameters.
+ TestSignatures sigs;
+ for (byte num_params = 0; num_params < 40; num_params++) {
+ v8::base::AccountingAllocator allocator;
+ Zone zone(&allocator);
+ HandleScope scope(CcTest::InitIsolateOnce());
+ TestingModule module(kExecuteCompiled);
+ FunctionSig* sig = sigs.many(&zone, kAstStmt, param, num_params);
+
+ module.AddSignature(sig);
+ module.AddSignature(sig);
+ module.AddIndirectFunctionTable(nullptr, 0);
+
+ WasmFunctionCompiler t(sig, &module);
+
+ std::vector<byte> code;
+ 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_i64) { CompileCallIndirectMany(kAstI64); }
+
+static void Run_WasmMixedCall_N(WasmExecutionMode execution_mode, int start) {
+ const int kExpected = 6333;
+ const int kElemSize = 8;
+ TestSignatures sigs;
+
+ static MachineType mixed[] = {
+ MachineType::Int32(), MachineType::Float32(), MachineType::Int64(),
+ MachineType::Float64(), MachineType::Float32(), MachineType::Int64(),
+ MachineType::Int32(), MachineType::Float64(), MachineType::Float32(),
+ MachineType::Float64(), MachineType::Int32(), MachineType::Int64(),
+ MachineType::Int32(), MachineType::Int32()};
+
+ int num_params = static_cast<int>(arraysize(mixed)) - start;
+ for (int which = 0; which < num_params; which++) {
+ v8::base::AccountingAllocator allocator;
+ Zone zone(&allocator);
+ TestingModule module(execution_mode);
+ module.AddMemory(1024);
+ MachineType* memtypes = &mixed[start];
+ MachineType result = memtypes[which];
+
+ // =========================================================================
+ // Build the selector function.
+ // =========================================================================
+ uint32_t index;
+ FunctionSig::Builder b(&zone, 1, num_params);
+ b.AddReturn(WasmOpcodes::LocalTypeFor(result));
+ for (int i = 0; i < num_params; i++) {
+ b.AddParam(WasmOpcodes::LocalTypeFor(memtypes[i]));
+ }
+ WasmFunctionCompiler t(b.Build(), &module);
+ BUILD(t, WASM_GET_LOCAL(which));
+ index = t.CompileAndAdd();
+
+ // =========================================================================
+ // Build the calling function.
+ // =========================================================================
+ WasmRunner<int32_t> r(&module);
+ std::vector<byte> code;
+
+ // 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));
+
+ r.Build(&code[0], &code[0] + code.size());
+
+ // Run the code.
+ for (int t = 0; t < 10; t++) {
+ module.RandomizeMemory();
+ CHECK_EQ(kExpected, r.Call());
+
+ int size = WasmOpcodes::MemSize(result);
+ for (int i = 0; i < size; i++) {
+ int base = (which + 1) * kElemSize;
+ byte expected = module.raw_mem_at<byte>(base + i);
+ byte result = module.raw_mem_at<byte>(i);
+ CHECK_EQ(expected, result);
+ }
+ }
+ }
+}
+
+WASM_EXEC_TEST(MixedCall_i64_0) { Run_WasmMixedCall_N(execution_mode, 0); }
+WASM_EXEC_TEST(MixedCall_i64_1) { Run_WasmMixedCall_N(execution_mode, 1); }
+WASM_EXEC_TEST(MixedCall_i64_2) { Run_WasmMixedCall_N(execution_mode, 2); }
+WASM_EXEC_TEST(MixedCall_i64_3) { Run_WasmMixedCall_N(execution_mode, 3); }
diff --git a/test/cctest/wasm/test-run-wasm-asmjs.cc b/test/cctest/wasm/test-run-wasm-asmjs.cc
index c597fc8..4d39dd6 100644
--- a/test/cctest/wasm/test-run-wasm-asmjs.cc
+++ b/test/cctest/wasm/test-run-wasm-asmjs.cc
@@ -26,8 +26,20 @@
#define RET(x) x, kExprReturn, 1
#define RET_I8(x) kExprI8Const, x, kExprReturn, 1
+namespace {
+uint32_t GetMatchingRelocInfoCount(Handle<Code> code, RelocInfo::Mode rmode) {
+ int filter = 1 << rmode;
+ uint32_t ret = 0;
+ for (RelocIterator it(*code, filter); !it.done(); it.next()) {
+ ++ret;
+ }
+ return ret;
+}
+}
+
WASM_EXEC_TEST(Int32AsmjsDivS) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
@@ -38,7 +50,8 @@
}
WASM_EXEC_TEST(Int32AsmjsRemS) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
@@ -49,7 +62,8 @@
}
WASM_EXEC_TEST(Int32AsmjsDivU) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
@@ -60,7 +74,8 @@
}
WASM_EXEC_TEST(Int32AsmjsRemU) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
@@ -71,7 +86,7 @@
}
WASM_EXEC_TEST(I32AsmjsSConvertF32) {
- WasmRunner<int32_t> r(MachineType::Float32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_UNOP(kExprI32AsmjsSConvertF32, WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -81,7 +96,7 @@
}
WASM_EXEC_TEST(I32AsmjsSConvertF64) {
- WasmRunner<int32_t> r(MachineType::Float64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_UNOP(kExprI32AsmjsSConvertF64, WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -91,7 +106,7 @@
}
WASM_EXEC_TEST(I32AsmjsUConvertF32) {
- WasmRunner<uint32_t> r(MachineType::Float32());
+ WasmRunner<uint32_t> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_UNOP(kExprI32AsmjsUConvertF32, WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -101,7 +116,7 @@
}
WASM_EXEC_TEST(I32AsmjsUConvertF64) {
- WasmRunner<uint32_t> r(MachineType::Float64());
+ WasmRunner<uint32_t> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_UNOP(kExprI32AsmjsUConvertF64, WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -111,7 +126,7 @@
}
WASM_EXEC_TEST(LoadMemI32_oob_asm) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module, MachineType::Uint32());
module.RandomizeMemory(1112);
@@ -131,7 +146,7 @@
}
WASM_EXEC_TEST(LoadMemF32_oob_asm) {
- TestingModule module;
+ TestingModule module(execution_mode);
float* memory = module.AddMemoryElems<float>(8);
WasmRunner<float> r(&module, MachineType::Uint32());
module.RandomizeMemory(1112);
@@ -151,7 +166,7 @@
}
WASM_EXEC_TEST(LoadMemF64_oob_asm) {
- TestingModule module;
+ TestingModule module(execution_mode);
double* memory = module.AddMemoryElems<double>(8);
WasmRunner<double> r(&module, MachineType::Uint32());
module.RandomizeMemory(1112);
@@ -173,7 +188,7 @@
}
WASM_EXEC_TEST(StoreMemI32_oob_asm) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module, MachineType::Uint32(), MachineType::Uint32());
module.RandomizeMemory(1112);
@@ -193,3 +208,90 @@
CHECK_EQ(7777, r.Call(offset, 7777));
}
}
+
+#define FOREACH_INT_CHECKED_LOAD_OP(TEST_BODY) \
+ TEST_BODY(kExprI32AsmjsLoadMem8S) \
+ TEST_BODY(kExprI32AsmjsLoadMem8U) \
+ TEST_BODY(kExprI32AsmjsLoadMem16S) \
+ TEST_BODY(kExprI32AsmjsLoadMem16U) \
+ TEST_BODY(kExprI32AsmjsLoadMem)
+
+#define FOREACH_INT_CHECKED_STORE_OP(TEST_BODY) \
+ TEST_BODY(kExprI32AsmjsStoreMem8) \
+ TEST_BODY(kExprI32AsmjsStoreMem16) \
+ TEST_BODY(kExprI32AsmjsStoreMem)
+
+#define INT_LOAD_TEST(OP_TYPE) \
+ TEST(RunWasm_AsmCheckedRelocInfo##OP_TYPE) { \
+ TestingModule module(kExecuteCompiled); \
+ WasmRunner<int32_t> r(&module, MachineType::Uint32()); \
+ BUILD(r, WASM_UNOP(OP_TYPE, WASM_GET_LOCAL(0))); \
+ CHECK_EQ(1, GetMatchingRelocInfoCount(module.instance->function_code[0], \
+ RelocInfo::WASM_MEMORY_REFERENCE)); \
+ CHECK_NE( \
+ 0, GetMatchingRelocInfoCount(module.instance->function_code[0], \
+ RelocInfo::WASM_MEMORY_SIZE_REFERENCE)); \
+ }
+
+FOREACH_INT_CHECKED_LOAD_OP(INT_LOAD_TEST)
+
+#define INT_STORE_TEST(OP_TYPE) \
+ TEST(RunWasm_AsmCheckedRelocInfo##OP_TYPE) { \
+ TestingModule module(kExecuteCompiled); \
+ WasmRunner<int32_t> r(&module, MachineType::Uint32(), \
+ MachineType::Uint32()); \
+ BUILD(r, WASM_BINOP(OP_TYPE, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); \
+ CHECK_EQ(1, GetMatchingRelocInfoCount(module.instance->function_code[0], \
+ RelocInfo::WASM_MEMORY_REFERENCE)); \
+ CHECK_NE( \
+ 0, GetMatchingRelocInfoCount(module.instance->function_code[0], \
+ RelocInfo::WASM_MEMORY_SIZE_REFERENCE)); \
+ }
+
+FOREACH_INT_CHECKED_STORE_OP(INT_STORE_TEST)
+
+TEST(RunWasm_AsmCheckedLoadFloat32RelocInfo) {
+ TestingModule module(kExecuteCompiled);
+ WasmRunner<float> r(&module, MachineType::Uint32());
+ BUILD(r, WASM_UNOP(kExprF32AsmjsLoadMem, WASM_GET_LOCAL(0)));
+
+ CHECK_EQ(1, GetMatchingRelocInfoCount(module.instance->function_code[0],
+ RelocInfo::WASM_MEMORY_REFERENCE));
+ CHECK_NE(0, GetMatchingRelocInfoCount(module.instance->function_code[0],
+ RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+}
+
+TEST(RunWasm_AsmCheckedStoreFloat32RelocInfo) {
+ TestingModule module(kExecuteCompiled);
+ WasmRunner<float> r(&module, MachineType::Uint32(), MachineType::Float32());
+ BUILD(r, WASM_BINOP(kExprF32AsmjsStoreMem, WASM_GET_LOCAL(0),
+ WASM_GET_LOCAL(1)));
+
+ CHECK_EQ(1, GetMatchingRelocInfoCount(module.instance->function_code[0],
+ RelocInfo::WASM_MEMORY_REFERENCE));
+ CHECK_NE(0, GetMatchingRelocInfoCount(module.instance->function_code[0],
+ RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+}
+
+TEST(RunWasm_AsmCheckedLoadFloat64RelocInfo) {
+ TestingModule module(kExecuteCompiled);
+ WasmRunner<double> r(&module, MachineType::Uint32());
+ BUILD(r, WASM_UNOP(kExprF64AsmjsLoadMem, WASM_GET_LOCAL(0)));
+
+ CHECK_EQ(1, GetMatchingRelocInfoCount(module.instance->function_code[0],
+ RelocInfo::WASM_MEMORY_REFERENCE));
+ CHECK_NE(0, GetMatchingRelocInfoCount(module.instance->function_code[0],
+ RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+}
+
+TEST(RunWasm_AsmCheckedStoreFloat64RelocInfo) {
+ TestingModule module(kExecuteCompiled);
+ WasmRunner<double> r(&module, MachineType::Uint32(), MachineType::Float64());
+ BUILD(r, WASM_BINOP(kExprF64AsmjsStoreMem, WASM_GET_LOCAL(0),
+ WASM_GET_LOCAL(1)));
+
+ CHECK_EQ(1, GetMatchingRelocInfoCount(module.instance->function_code[0],
+ RelocInfo::WASM_MEMORY_REFERENCE));
+ CHECK_NE(0, GetMatchingRelocInfoCount(module.instance->function_code[0],
+ RelocInfo::WASM_MEMORY_SIZE_REFERENCE));
+}
diff --git a/test/cctest/wasm/test-run-wasm-interpreter.cc b/test/cctest/wasm/test-run-wasm-interpreter.cc
new file mode 100644
index 0000000..42b0f88
--- /dev/null
+++ b/test/cctest/wasm/test-run-wasm-interpreter.cc
@@ -0,0 +1,289 @@
+// 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/wasm/wasm-macro-gen.h"
+
+#include "src/wasm/wasm-interpreter.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;
+
+namespace v8 {
+namespace internal {
+namespace wasm {
+
+TEST(Run_WasmInt8Const_i) {
+ WasmRunner<int32_t> r(kExecuteInterpreted);
+ const byte kExpectedValue = 109;
+ // return(kExpectedValue)
+ BUILD(r, WASM_I8(kExpectedValue));
+ CHECK_EQ(kExpectedValue, r.Call());
+}
+
+TEST(Run_WasmIfElse) {
+ WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Int32());
+ BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_I8(9), WASM_I8(10)));
+ CHECK_EQ(10, r.Call(0));
+ CHECK_EQ(9, r.Call(1));
+}
+
+TEST(Run_WasmIfReturn) {
+ WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Int32());
+ BUILD(r, WASM_IF(WASM_GET_LOCAL(0), WASM_RETURN1(WASM_I8(77))), WASM_I8(65));
+ CHECK_EQ(65, r.Call(0));
+ CHECK_EQ(77, r.Call(1));
+}
+
+TEST(Run_WasmNopsN) {
+ const int kMaxNops = 10;
+ byte code[kMaxNops + 2];
+ for (int nops = 0; nops < kMaxNops; nops++) {
+ byte expected = static_cast<byte>(20 + nops);
+ memset(code, kExprNop, sizeof(code));
+ code[nops] = kExprI8Const;
+ code[nops + 1] = expected;
+
+ WasmRunner<int32_t> r(kExecuteInterpreted);
+ r.Build(code, code + nops + 2);
+ CHECK_EQ(expected, r.Call());
+ }
+}
+
+TEST(Run_WasmConstsN) {
+ const int kMaxConsts = 10;
+ byte code[kMaxConsts * 2];
+ for (int count = 1; count < kMaxConsts; count++) {
+ for (int i = 0; i < count; i++) {
+ code[i * 2] = kExprI8Const;
+ code[i * 2 + 1] = static_cast<byte>(count * 10 + i);
+ }
+ byte expected = static_cast<byte>(count * 11 - 1);
+
+ WasmRunner<int32_t> r(kExecuteInterpreted);
+ r.Build(code, code + (count * 2));
+ CHECK_EQ(expected, r.Call());
+ }
+}
+
+TEST(Run_WasmBlocksN) {
+ const int kMaxNops = 10;
+ const int kExtra = 4;
+ byte code[kMaxNops + kExtra];
+ for (int nops = 0; nops < kMaxNops; nops++) {
+ byte expected = static_cast<byte>(30 + nops);
+ memset(code, kExprNop, sizeof(code));
+ code[0] = kExprBlock;
+ code[1 + nops] = kExprI8Const;
+ code[1 + nops + 1] = expected;
+ code[1 + nops + 2] = kExprEnd;
+
+ WasmRunner<int32_t> r(kExecuteInterpreted);
+ r.Build(code, code + nops + kExtra);
+ CHECK_EQ(expected, r.Call());
+ }
+}
+
+TEST(Run_WasmBlockBreakN) {
+ const int kMaxNops = 10;
+ const int kExtra = 6;
+ byte code[kMaxNops + kExtra];
+ for (int nops = 0; nops < kMaxNops; nops++) {
+ // Place the break anywhere within the block.
+ for (int index = 0; index < nops; index++) {
+ memset(code, kExprNop, sizeof(code));
+ code[0] = kExprBlock;
+ code[sizeof(code) - 1] = kExprEnd;
+
+ int expected = nops * 11 + index;
+ code[1 + index + 0] = kExprI8Const;
+ code[1 + index + 1] = static_cast<byte>(expected);
+ code[1 + index + 2] = kExprBr;
+ code[1 + index + 3] = ARITY_1;
+ code[1 + index + 4] = 0;
+
+ WasmRunner<int32_t> r(kExecuteInterpreted);
+ r.Build(code, code + kMaxNops + kExtra);
+ CHECK_EQ(expected, r.Call());
+ }
+ }
+}
+
+TEST(Run_Wasm_nested_ifs_i) {
+ WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Int32(),
+ MachineType::Int32());
+
+ BUILD(r, WASM_IF_ELSE(
+ WASM_GET_LOCAL(0),
+ 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));
+}
+
+// Make tests more robust by not hard-coding offsets of various operations.
+// The {Find} method finds the offsets for the given bytecodes, returning
+// the offsets in an array.
+SmartArrayPointer<int> Find(byte* code, size_t code_size, int n, ...) {
+ va_list vl;
+ va_start(vl, n);
+
+ SmartArrayPointer<int> offsets(new int[n]);
+
+ for (int i = 0; i < n; i++) {
+ offsets[i] = -1;
+ }
+
+ int pos = 0;
+ WasmOpcode current = static_cast<WasmOpcode>(va_arg(vl, int));
+ for (size_t i = 0; i < code_size; i++) {
+ if (code[i] == current) {
+ offsets[pos++] = static_cast<int>(i);
+ if (pos == n) break;
+ current = static_cast<WasmOpcode>(va_arg(vl, int));
+ }
+ }
+ va_end(vl);
+
+ return offsets;
+}
+
+TEST(Breakpoint_I32Add) {
+ static const int kLocalsDeclSize = 1;
+ static const int kNumBreakpoints = 3;
+ byte code[] = {WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
+ SmartArrayPointer<int> offsets =
+ Find(code, sizeof(code), kNumBreakpoints, kExprGetLocal, kExprGetLocal,
+ kExprI32Add);
+
+ WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
+ MachineType::Uint32());
+
+ r.Build(code, code + arraysize(code));
+
+ WasmInterpreter* interpreter = r.interpreter();
+ WasmInterpreter::Thread* thread = interpreter->GetThread(0);
+ for (int i = 0; i < kNumBreakpoints; i++) {
+ interpreter->SetBreakpoint(r.function(), kLocalsDeclSize + offsets[i],
+ true);
+ }
+
+ FOR_UINT32_INPUTS(a) {
+ for (uint32_t b = 11; b < 3000000000u; b += 1000000000u) {
+ thread->Reset();
+ WasmVal args[] = {WasmVal(*a), WasmVal(b)};
+ thread->PushFrame(r.function(), args);
+
+ for (int i = 0; i < kNumBreakpoints; i++) {
+ thread->Run(); // run to next breakpoint
+ // Check the thread stopped at the right pc.
+ CHECK_EQ(WasmInterpreter::PAUSED, thread->state());
+ CHECK_EQ(kLocalsDeclSize + offsets[i], thread->GetBreakpointPc());
+ }
+
+ thread->Run(); // run to completion
+
+ // Check the thread finished with the right value.
+ CHECK_EQ(WasmInterpreter::FINISHED, thread->state());
+ uint32_t expected = (*a) + (b);
+ CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
+ }
+ }
+}
+
+TEST(Step_I32Mul) {
+ static const int kTraceLength = 4;
+ byte code[] = {WASM_I32_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
+
+ WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
+ MachineType::Uint32());
+
+ r.Build(code, code + arraysize(code));
+
+ WasmInterpreter* interpreter = r.interpreter();
+ WasmInterpreter::Thread* thread = interpreter->GetThread(0);
+
+ FOR_UINT32_INPUTS(a) {
+ for (uint32_t b = 33; b < 3000000000u; b += 1000000000u) {
+ thread->Reset();
+ WasmVal args[] = {WasmVal(*a), WasmVal(b)};
+ thread->PushFrame(r.function(), args);
+
+ // Run instructions one by one.
+ for (int i = 0; i < kTraceLength - 1; i++) {
+ thread->Step();
+ // Check the thread stopped.
+ CHECK_EQ(WasmInterpreter::PAUSED, thread->state());
+ }
+
+ // Run last instruction.
+ thread->Step();
+
+ // Check the thread finished with the right value.
+ CHECK_EQ(WasmInterpreter::FINISHED, thread->state());
+ uint32_t expected = (*a) * (b);
+ CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
+ }
+ }
+}
+
+TEST(Breakpoint_I32And_disable) {
+ static const int kLocalsDeclSize = 1;
+ static const int kNumBreakpoints = 1;
+ byte code[] = {WASM_I32_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
+ SmartArrayPointer<int> offsets =
+ Find(code, sizeof(code), kNumBreakpoints, kExprI32And);
+
+ WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
+ MachineType::Uint32());
+
+ r.Build(code, code + arraysize(code));
+
+ WasmInterpreter* interpreter = r.interpreter();
+ WasmInterpreter::Thread* thread = interpreter->GetThread(0);
+
+ FOR_UINT32_INPUTS(a) {
+ for (uint32_t b = 11; b < 3000000000u; b += 1000000000u) {
+ // Run with and without breakpoints.
+ for (int do_break = 0; do_break < 2; do_break++) {
+ interpreter->SetBreakpoint(r.function(), kLocalsDeclSize + offsets[0],
+ do_break);
+ thread->Reset();
+ WasmVal args[] = {WasmVal(*a), WasmVal(b)};
+ thread->PushFrame(r.function(), args);
+
+ if (do_break) {
+ thread->Run(); // run to next breakpoint
+ // Check the thread stopped at the right pc.
+ CHECK_EQ(WasmInterpreter::PAUSED, thread->state());
+ CHECK_EQ(kLocalsDeclSize + offsets[0], thread->GetBreakpointPc());
+ }
+
+ thread->Run(); // run to completion
+
+ // Check the thread finished with the right value.
+ CHECK_EQ(WasmInterpreter::FINISHED, thread->state());
+ uint32_t expected = (*a) & (b);
+ CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
+ }
+ }
+ }
+}
+
+} // namespace wasm
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/wasm/test-run-wasm-module.cc b/test/cctest/wasm/test-run-wasm-module.cc
index 05edd62..7a79d67 100644
--- a/test/cctest/wasm/test-run-wasm-module.cc
+++ b/test/cctest/wasm/test-run-wasm-module.cc
@@ -20,14 +20,24 @@
using namespace v8::internal::wasm;
namespace {
-void TestModule(WasmModuleIndex* module, int32_t expected_result) {
+void TestModule(Zone* zone, WasmModuleBuilder* builder,
+ int32_t expected_result) {
+ ZoneBuffer buffer(zone);
+ builder->WriteTo(buffer);
+
Isolate* isolate = CcTest::InitIsolateOnce();
HandleScope scope(isolate);
WasmJs::InstallWasmFunctionMap(isolate, isolate->native_context());
int32_t result =
- CompileAndRunWasmModule(isolate, module->Begin(), module->End());
+ testing::CompileAndRunWasmModule(isolate, buffer.begin(), buffer.end());
CHECK_EQ(expected_result, result);
}
+
+void ExportAsMain(WasmFunctionBuilder* f) {
+ static const char kMainName[] = "main";
+ f->SetExported();
+ f->SetName(kMainName, arraysize(kMainName) - 1);
+}
} // namespace
TEST(Run_WasmModule_Return114) {
@@ -40,11 +50,10 @@
uint16_t f_index = builder->AddFunction();
WasmFunctionBuilder* f = builder->FunctionAt(f_index);
f->SetSignature(sigs.i_v());
- f->Exported(1);
+ ExportAsMain(f);
byte code[] = {WASM_I8(kReturnValue)};
f->EmitCode(code, sizeof(code));
- WasmModuleWriter* writer = builder->Build(&zone);
- TestModule(writer->WriteTo(&zone), kReturnValue);
+ TestModule(&zone, builder, kReturnValue);
}
TEST(Run_WasmModule_CallAdd) {
@@ -66,11 +75,10 @@
f = builder->FunctionAt(f2_index);
f->SetSignature(sigs.i_v());
- f->Exported(1);
+ ExportAsMain(f);
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);
+ TestModule(&zone, builder, 99);
}
TEST(Run_WasmModule_ReadLoadedDataSegment) {
@@ -84,15 +92,14 @@
WasmFunctionBuilder* f = builder->FunctionAt(f_index);
f->SetSignature(sigs.i_v());
- f->Exported(1);
+ ExportAsMain(f);
byte code[] = {
WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(kDataSegmentDest0))};
f->EmitCode(code, sizeof(code));
byte data[] = {0xaa, 0xbb, 0xcc, 0xdd};
builder->AddDataSegment(new (&zone) WasmDataSegmentEncoder(
&zone, data, sizeof(data), kDataSegmentDest0));
- WasmModuleWriter* writer = builder->Build(&zone);
- TestModule(writer->WriteTo(&zone), 0xddccbbaa);
+ TestModule(&zone, builder, 0xddccbbaa);
}
TEST(Run_WasmModule_CheckMemoryIsZero) {
@@ -107,7 +114,7 @@
f->SetSignature(sigs.i_v());
uint16_t localIndex = f->AddLocal(kAstI32);
- f->Exported(1);
+ ExportAsMain(f);
byte code[] = {WASM_BLOCK(
2,
WASM_WHILE(
@@ -117,8 +124,7 @@
WASM_BRV(2, WASM_I8(-1)), WASM_INC_LOCAL_BY(localIndex, 4))),
WASM_I8(11))};
f->EmitCode(code, sizeof(code));
- WasmModuleWriter* writer = builder->Build(&zone);
- TestModule(writer->WriteTo(&zone), 11);
+ TestModule(&zone, builder, 11);
}
TEST(Run_WasmModule_CallMain_recursive) {
@@ -132,7 +138,7 @@
f->SetSignature(sigs.i_v());
uint16_t localIndex = f->AddLocal(kAstI32);
- f->Exported(1);
+ ExportAsMain(f);
byte code[] = {WASM_BLOCK(
2, WASM_SET_LOCAL(localIndex,
WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO)),
@@ -142,8 +148,7 @@
WASM_BRV(1, WASM_CALL_FUNCTION0(0))),
WASM_BRV(0, WASM_I8(55))))};
f->EmitCode(code, sizeof(code));
- WasmModuleWriter* writer = builder->Build(&zone);
- TestModule(writer->WriteTo(&zone), 55);
+ TestModule(&zone, builder, 55);
}
TEST(Run_WasmModule_Global) {
@@ -163,11 +168,10 @@
uint16_t f2_index = builder->AddFunction();
f = builder->FunctionAt(f2_index);
f->SetSignature(sigs.i_v());
- f->Exported(1);
+ ExportAsMain(f);
byte code2[] = {WASM_STORE_GLOBAL(global1, WASM_I32V_1(56)),
WASM_STORE_GLOBAL(global2, WASM_I32V_1(41)),
WASM_RETURN1(WASM_CALL_FUNCTION0(f1_index))};
f->EmitCode(code2, sizeof(code2));
- WasmModuleWriter* writer = builder->Build(&zone);
- TestModule(writer->WriteTo(&zone), 97);
+ TestModule(&zone, builder, 97);
}
diff --git a/test/cctest/wasm/test-run-wasm-relocation.cc b/test/cctest/wasm/test-run-wasm-relocation.cc
new file mode 100644
index 0000000..6b1f643
--- /dev/null
+++ b/test/cctest/wasm/test-run-wasm-relocation.cc
@@ -0,0 +1,64 @@
+// 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 "test/cctest/cctest.h"
+#include "test/cctest/compiler/c-signature.h"
+#include "test/cctest/wasm/wasm-run-utils.h"
+
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+
+#define FOREACH_TYPE(TEST_BODY) \
+ TEST_BODY(int8_t, Int8, WASM_I32_ADD) \
+ TEST_BODY(uint8_t, Uint8, WASM_I32_ADD) \
+ TEST_BODY(int16_t, Int16, WASM_I32_ADD) \
+ TEST_BODY(uint16_t, Uint16, WASM_I32_ADD) \
+ TEST_BODY(int32_t, Int32, WASM_I32_ADD) \
+ TEST_BODY(uint32_t, Uint32, WASM_I32_ADD) \
+ TEST_BODY(float, Float32, WASM_F32_ADD) \
+ TEST_BODY(double, Float64, WASM_F64_ADD)
+
+#define LOAD_STORE_GLOBAL_TEST_BODY(C_TYPE, MACHINE_TYPE, ADD) \
+ TEST(WasmRelocateGlobal##MACHINE_TYPE) { \
+ TestingModule module(kExecuteCompiled); \
+ module.AddGlobal<int32_t>(MachineType::MACHINE_TYPE()); \
+ module.AddGlobal<int32_t>(MachineType::MACHINE_TYPE()); \
+ \
+ WasmRunner<C_TYPE> r(&module, MachineType::MACHINE_TYPE()); \
+ \
+ /* global = global + p0 */ \
+ BUILD(r, \
+ WASM_STORE_GLOBAL(1, ADD(WASM_LOAD_GLOBAL(0), WASM_GET_LOCAL(0)))); \
+ CHECK_EQ(1, module.instance->function_code.size()); \
+ \
+ int filter = 1 << RelocInfo::WASM_GLOBAL_REFERENCE; \
+ \
+ Handle<Code> code = module.instance->function_code[0]; \
+ \
+ Address old_start = module.instance->globals_start; \
+ Address new_start = old_start + 1; \
+ \
+ Address old_addresses[2]; \
+ uint32_t address_index = 0U; \
+ for (RelocIterator it(*code, filter); !it.done(); it.next()) { \
+ old_addresses[address_index] = it.rinfo()->wasm_global_reference(); \
+ it.rinfo()->update_wasm_global_reference(old_start, new_start); \
+ ++address_index; \
+ } \
+ CHECK_EQ(2U, address_index); \
+ \
+ address_index = 0U; \
+ for (RelocIterator it(*code, filter); !it.done(); it.next()) { \
+ CHECK_EQ(old_addresses[address_index] + 1, \
+ it.rinfo()->wasm_global_reference()); \
+ ++address_index; \
+ } \
+ CHECK_EQ(2U, address_index); \
+ }
+
+FOREACH_TYPE(LOAD_STORE_GLOBAL_TEST_BODY)
diff --git a/test/cctest/wasm/test-run-wasm.cc b/test/cctest/wasm/test-run-wasm.cc
index 236624f..ec7c5e7 100644
--- a/test/cctest/wasm/test-run-wasm.cc
+++ b/test/cctest/wasm/test-run-wasm.cc
@@ -27,7 +27,7 @@
#define RET_I8(x) kExprI8Const, x, kExprReturn, 1
WASM_EXEC_TEST(Int8Const) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
const byte kExpectedValue = 121;
// return(kExpectedValue)
BUILD(r, WASM_I8(kExpectedValue));
@@ -35,7 +35,7 @@
}
WASM_EXEC_TEST(Int8Const_fallthru1) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
const byte kExpectedValue = 122;
// kExpectedValue
BUILD(r, WASM_I8(kExpectedValue));
@@ -43,7 +43,7 @@
}
WASM_EXEC_TEST(Int8Const_fallthru2) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
const byte kExpectedValue = 123;
// -99 kExpectedValue
BUILD(r, WASM_I8(-99), WASM_I8(kExpectedValue));
@@ -51,8 +51,8 @@
}
WASM_EXEC_TEST(Int8Const_all) {
- for (int value = -128; value <= 127; value++) {
- WasmRunner<int32_t> r;
+ for (int value = -128; value <= 127; ++value) {
+ WasmRunner<int32_t> r(execution_mode);
// return(value)
BUILD(r, WASM_I8(value));
int32_t result = r.Call();
@@ -61,7 +61,7 @@
}
WASM_EXEC_TEST(Int32Const) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
const int32_t kExpectedValue = 0x11223344;
// return(kExpectedValue)
BUILD(r, WASM_I32V_5(kExpectedValue));
@@ -70,7 +70,7 @@
WASM_EXEC_TEST(Int32Const_many) {
FOR_INT32_INPUTS(i) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
const int32_t kExpectedValue = *i;
// return(kExpectedValue)
BUILD(r, WASM_I32V(kExpectedValue));
@@ -79,7 +79,7 @@
}
WASM_EXEC_TEST(MemorySize) {
- TestingModule module;
+ TestingModule module(execution_mode);
WasmRunner<int32_t> r(&module);
module.AddMemory(1024);
BUILD(r, kExprMemorySize);
@@ -87,49 +87,51 @@
}
WASM_EXEC_TEST(Int32Param0) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// return(local[0])
BUILD(r, WASM_GET_LOCAL(0));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
}
WASM_EXEC_TEST(Int32Param0_fallthru) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// local[0]
BUILD(r, WASM_GET_LOCAL(0));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
}
WASM_EXEC_TEST(Int32Param1) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
+ MachineType::Int32());
// local[1]
BUILD(r, WASM_GET_LOCAL(1));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(-111, *i)); }
}
WASM_EXEC_TEST(Int32Add) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// 11 + 44
BUILD(r, WASM_I32_ADD(WASM_I8(11), WASM_I8(44)));
CHECK_EQ(55, r.Call());
}
WASM_EXEC_TEST(Int32Add_P) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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)); }
}
WASM_EXEC_TEST(Int32Add_P_fallthru) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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)); }
}
WASM_EXEC_TEST(Int32Add_P2) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
+ MachineType::Int32());
// p0 + p1
BUILD(r, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT32_INPUTS(i) {
@@ -142,7 +144,7 @@
}
WASM_EXEC_TEST(Float32Add) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// int(11.5f + 44.5f)
BUILD(r,
WASM_I32_SCONVERT_F32(WASM_F32_ADD(WASM_F32(11.5f), WASM_F32(44.5f))));
@@ -150,21 +152,23 @@
}
WASM_EXEC_TEST(Float64Add) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// 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) {
+void TestInt32Binop(WasmExecutionMode execution_mode, WasmOpcode opcode,
+ int32_t expected, int32_t a, int32_t b) {
{
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// K op K
BUILD(r, WASM_BINOP(opcode, WASM_I32V(a), WASM_I32V(b)));
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
+ MachineType::Int32());
// a op b
BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(expected, r.Call(a, b));
@@ -172,46 +176,48 @@
}
WASM_EXEC_TEST(Int32Binops) {
- TestInt32Binop(kExprI32Add, 88888888, 33333333, 55555555);
- TestInt32Binop(kExprI32Sub, -1111111, 7777777, 8888888);
- TestInt32Binop(kExprI32Mul, 65130756, 88734, 734);
- TestInt32Binop(kExprI32DivS, -66, -4777344, 72384);
- TestInt32Binop(kExprI32DivU, 805306368, 0xF0000000, 5);
- TestInt32Binop(kExprI32RemS, -3, -3003, 1000);
- TestInt32Binop(kExprI32RemU, 4, 4004, 1000);
- TestInt32Binop(kExprI32And, 0xEE, 0xFFEE, 0xFF0000FF);
- TestInt32Binop(kExprI32Ior, 0xF0FF00FF, 0xF0F000EE, 0x000F0011);
- TestInt32Binop(kExprI32Xor, 0xABCDEF01, 0xABCDEFFF, 0xFE);
- TestInt32Binop(kExprI32Shl, 0xA0000000, 0xA, 28);
- TestInt32Binop(kExprI32ShrU, 0x07000010, 0x70000100, 4);
- TestInt32Binop(kExprI32ShrS, 0xFF000000, 0x80000000, 7);
- TestInt32Binop(kExprI32Ror, 0x01000000, 0x80000000, 7);
- TestInt32Binop(kExprI32Ror, 0x01000000, 0x80000000, 39);
- TestInt32Binop(kExprI32Rol, 0x00000040, 0x80000000, 7);
- TestInt32Binop(kExprI32Rol, 0x00000040, 0x80000000, 39);
- TestInt32Binop(kExprI32Eq, 1, -99, -99);
- TestInt32Binop(kExprI32Ne, 0, -97, -97);
+ TestInt32Binop(execution_mode, kExprI32Add, 88888888, 33333333, 55555555);
+ TestInt32Binop(execution_mode, kExprI32Sub, -1111111, 7777777, 8888888);
+ TestInt32Binop(execution_mode, kExprI32Mul, 65130756, 88734, 734);
+ TestInt32Binop(execution_mode, kExprI32DivS, -66, -4777344, 72384);
+ TestInt32Binop(execution_mode, kExprI32DivU, 805306368, 0xF0000000, 5);
+ TestInt32Binop(execution_mode, kExprI32RemS, -3, -3003, 1000);
+ TestInt32Binop(execution_mode, kExprI32RemU, 4, 4004, 1000);
+ TestInt32Binop(execution_mode, kExprI32And, 0xEE, 0xFFEE, 0xFF0000FF);
+ TestInt32Binop(execution_mode, kExprI32Ior, 0xF0FF00FF, 0xF0F000EE,
+ 0x000F0011);
+ TestInt32Binop(execution_mode, kExprI32Xor, 0xABCDEF01, 0xABCDEFFF, 0xFE);
+ TestInt32Binop(execution_mode, kExprI32Shl, 0xA0000000, 0xA, 28);
+ TestInt32Binop(execution_mode, kExprI32ShrU, 0x07000010, 0x70000100, 4);
+ TestInt32Binop(execution_mode, kExprI32ShrS, 0xFF000000, 0x80000000, 7);
+ TestInt32Binop(execution_mode, kExprI32Ror, 0x01000000, 0x80000000, 7);
+ TestInt32Binop(execution_mode, kExprI32Ror, 0x01000000, 0x80000000, 39);
+ TestInt32Binop(execution_mode, kExprI32Rol, 0x00000040, 0x80000000, 7);
+ TestInt32Binop(execution_mode, kExprI32Rol, 0x00000040, 0x80000000, 39);
+ TestInt32Binop(execution_mode, kExprI32Eq, 1, -99, -99);
+ TestInt32Binop(execution_mode, kExprI32Ne, 0, -97, -97);
- TestInt32Binop(kExprI32LtS, 1, -4, 4);
- TestInt32Binop(kExprI32LeS, 0, -2, -3);
- TestInt32Binop(kExprI32LtU, 1, 0, -6);
- TestInt32Binop(kExprI32LeU, 1, 98978, 0xF0000000);
+ TestInt32Binop(execution_mode, kExprI32LtS, 1, -4, 4);
+ TestInt32Binop(execution_mode, kExprI32LeS, 0, -2, -3);
+ TestInt32Binop(execution_mode, kExprI32LtU, 1, 0, -6);
+ TestInt32Binop(execution_mode, kExprI32LeU, 1, 98978, 0xF0000000);
- TestInt32Binop(kExprI32GtS, 1, 4, -4);
- TestInt32Binop(kExprI32GeS, 0, -3, -2);
- TestInt32Binop(kExprI32GtU, 1, -6, 0);
- TestInt32Binop(kExprI32GeU, 1, 0xF0000000, 98978);
+ TestInt32Binop(execution_mode, kExprI32GtS, 1, 4, -4);
+ TestInt32Binop(execution_mode, kExprI32GeS, 0, -3, -2);
+ TestInt32Binop(execution_mode, kExprI32GtU, 1, -6, 0);
+ TestInt32Binop(execution_mode, kExprI32GeU, 1, 0xF0000000, 98978);
}
-void TestInt32Unop(WasmOpcode opcode, int32_t expected, int32_t a) {
+void TestInt32Unop(WasmExecutionMode execution_mode, WasmOpcode opcode,
+ int32_t expected, int32_t a) {
{
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// return op K
BUILD(r, WASM_UNOP(opcode, WASM_I32V(a)));
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// return op a
BUILD(r, WASM_UNOP(opcode, WASM_GET_LOCAL(0)));
CHECK_EQ(expected, r.Call(a));
@@ -219,95 +225,96 @@
}
WASM_EXEC_TEST(Int32Clz) {
- TestInt32Unop(kExprI32Clz, 0, 0x80001000);
- TestInt32Unop(kExprI32Clz, 1, 0x40000500);
- TestInt32Unop(kExprI32Clz, 2, 0x20000300);
- TestInt32Unop(kExprI32Clz, 3, 0x10000003);
- TestInt32Unop(kExprI32Clz, 4, 0x08050000);
- TestInt32Unop(kExprI32Clz, 5, 0x04006000);
- TestInt32Unop(kExprI32Clz, 6, 0x02000000);
- TestInt32Unop(kExprI32Clz, 7, 0x010000a0);
- TestInt32Unop(kExprI32Clz, 8, 0x00800c00);
- TestInt32Unop(kExprI32Clz, 9, 0x00400000);
- TestInt32Unop(kExprI32Clz, 10, 0x0020000d);
- TestInt32Unop(kExprI32Clz, 11, 0x00100f00);
- TestInt32Unop(kExprI32Clz, 12, 0x00080000);
- TestInt32Unop(kExprI32Clz, 13, 0x00041000);
- TestInt32Unop(kExprI32Clz, 14, 0x00020020);
- TestInt32Unop(kExprI32Clz, 15, 0x00010300);
- TestInt32Unop(kExprI32Clz, 16, 0x00008040);
- TestInt32Unop(kExprI32Clz, 17, 0x00004005);
- TestInt32Unop(kExprI32Clz, 18, 0x00002050);
- TestInt32Unop(kExprI32Clz, 19, 0x00001700);
- TestInt32Unop(kExprI32Clz, 20, 0x00000870);
- TestInt32Unop(kExprI32Clz, 21, 0x00000405);
- TestInt32Unop(kExprI32Clz, 22, 0x00000203);
- TestInt32Unop(kExprI32Clz, 23, 0x00000101);
- TestInt32Unop(kExprI32Clz, 24, 0x00000089);
- TestInt32Unop(kExprI32Clz, 25, 0x00000041);
- TestInt32Unop(kExprI32Clz, 26, 0x00000022);
- TestInt32Unop(kExprI32Clz, 27, 0x00000013);
- TestInt32Unop(kExprI32Clz, 28, 0x00000008);
- TestInt32Unop(kExprI32Clz, 29, 0x00000004);
- TestInt32Unop(kExprI32Clz, 30, 0x00000002);
- TestInt32Unop(kExprI32Clz, 31, 0x00000001);
- TestInt32Unop(kExprI32Clz, 32, 0x00000000);
+ TestInt32Unop(execution_mode, kExprI32Clz, 0, 0x80001000);
+ TestInt32Unop(execution_mode, kExprI32Clz, 1, 0x40000500);
+ TestInt32Unop(execution_mode, kExprI32Clz, 2, 0x20000300);
+ TestInt32Unop(execution_mode, kExprI32Clz, 3, 0x10000003);
+ TestInt32Unop(execution_mode, kExprI32Clz, 4, 0x08050000);
+ TestInt32Unop(execution_mode, kExprI32Clz, 5, 0x04006000);
+ TestInt32Unop(execution_mode, kExprI32Clz, 6, 0x02000000);
+ TestInt32Unop(execution_mode, kExprI32Clz, 7, 0x010000a0);
+ TestInt32Unop(execution_mode, kExprI32Clz, 8, 0x00800c00);
+ TestInt32Unop(execution_mode, kExprI32Clz, 9, 0x00400000);
+ TestInt32Unop(execution_mode, kExprI32Clz, 10, 0x0020000d);
+ TestInt32Unop(execution_mode, kExprI32Clz, 11, 0x00100f00);
+ TestInt32Unop(execution_mode, kExprI32Clz, 12, 0x00080000);
+ TestInt32Unop(execution_mode, kExprI32Clz, 13, 0x00041000);
+ TestInt32Unop(execution_mode, kExprI32Clz, 14, 0x00020020);
+ TestInt32Unop(execution_mode, kExprI32Clz, 15, 0x00010300);
+ TestInt32Unop(execution_mode, kExprI32Clz, 16, 0x00008040);
+ TestInt32Unop(execution_mode, kExprI32Clz, 17, 0x00004005);
+ TestInt32Unop(execution_mode, kExprI32Clz, 18, 0x00002050);
+ TestInt32Unop(execution_mode, kExprI32Clz, 19, 0x00001700);
+ TestInt32Unop(execution_mode, kExprI32Clz, 20, 0x00000870);
+ TestInt32Unop(execution_mode, kExprI32Clz, 21, 0x00000405);
+ TestInt32Unop(execution_mode, kExprI32Clz, 22, 0x00000203);
+ TestInt32Unop(execution_mode, kExprI32Clz, 23, 0x00000101);
+ TestInt32Unop(execution_mode, kExprI32Clz, 24, 0x00000089);
+ TestInt32Unop(execution_mode, kExprI32Clz, 25, 0x00000041);
+ TestInt32Unop(execution_mode, kExprI32Clz, 26, 0x00000022);
+ TestInt32Unop(execution_mode, kExprI32Clz, 27, 0x00000013);
+ TestInt32Unop(execution_mode, kExprI32Clz, 28, 0x00000008);
+ TestInt32Unop(execution_mode, kExprI32Clz, 29, 0x00000004);
+ TestInt32Unop(execution_mode, kExprI32Clz, 30, 0x00000002);
+ TestInt32Unop(execution_mode, kExprI32Clz, 31, 0x00000001);
+ TestInt32Unop(execution_mode, kExprI32Clz, 32, 0x00000000);
}
WASM_EXEC_TEST(Int32Ctz) {
- TestInt32Unop(kExprI32Ctz, 32, 0x00000000);
- TestInt32Unop(kExprI32Ctz, 31, 0x80000000);
- TestInt32Unop(kExprI32Ctz, 30, 0x40000000);
- TestInt32Unop(kExprI32Ctz, 29, 0x20000000);
- TestInt32Unop(kExprI32Ctz, 28, 0x10000000);
- TestInt32Unop(kExprI32Ctz, 27, 0xa8000000);
- TestInt32Unop(kExprI32Ctz, 26, 0xf4000000);
- TestInt32Unop(kExprI32Ctz, 25, 0x62000000);
- TestInt32Unop(kExprI32Ctz, 24, 0x91000000);
- TestInt32Unop(kExprI32Ctz, 23, 0xcd800000);
- TestInt32Unop(kExprI32Ctz, 22, 0x09400000);
- TestInt32Unop(kExprI32Ctz, 21, 0xaf200000);
- TestInt32Unop(kExprI32Ctz, 20, 0xac100000);
- TestInt32Unop(kExprI32Ctz, 19, 0xe0b80000);
- TestInt32Unop(kExprI32Ctz, 18, 0x9ce40000);
- TestInt32Unop(kExprI32Ctz, 17, 0xc7920000);
- TestInt32Unop(kExprI32Ctz, 16, 0xb8f10000);
- TestInt32Unop(kExprI32Ctz, 15, 0x3b9f8000);
- TestInt32Unop(kExprI32Ctz, 14, 0xdb4c4000);
- TestInt32Unop(kExprI32Ctz, 13, 0xe9a32000);
- TestInt32Unop(kExprI32Ctz, 12, 0xfca61000);
- TestInt32Unop(kExprI32Ctz, 11, 0x6c8a7800);
- TestInt32Unop(kExprI32Ctz, 10, 0x8ce5a400);
- TestInt32Unop(kExprI32Ctz, 9, 0xcb7d0200);
- TestInt32Unop(kExprI32Ctz, 8, 0xcb4dc100);
- TestInt32Unop(kExprI32Ctz, 7, 0xdfbec580);
- TestInt32Unop(kExprI32Ctz, 6, 0x27a9db40);
- TestInt32Unop(kExprI32Ctz, 5, 0xde3bcb20);
- TestInt32Unop(kExprI32Ctz, 4, 0xd7e8a610);
- TestInt32Unop(kExprI32Ctz, 3, 0x9afdbc88);
- TestInt32Unop(kExprI32Ctz, 2, 0x9afdbc84);
- TestInt32Unop(kExprI32Ctz, 1, 0x9afdbc82);
- TestInt32Unop(kExprI32Ctz, 0, 0x9afdbc81);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 32, 0x00000000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 31, 0x80000000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 30, 0x40000000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 29, 0x20000000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 28, 0x10000000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 27, 0xa8000000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 26, 0xf4000000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 25, 0x62000000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 24, 0x91000000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 23, 0xcd800000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 22, 0x09400000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 21, 0xaf200000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 20, 0xac100000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 19, 0xe0b80000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 18, 0x9ce40000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 17, 0xc7920000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 16, 0xb8f10000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 15, 0x3b9f8000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 14, 0xdb4c4000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 13, 0xe9a32000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 12, 0xfca61000);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 11, 0x6c8a7800);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 10, 0x8ce5a400);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 9, 0xcb7d0200);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 8, 0xcb4dc100);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 7, 0xdfbec580);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 6, 0x27a9db40);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 5, 0xde3bcb20);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 4, 0xd7e8a610);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 3, 0x9afdbc88);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 2, 0x9afdbc84);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 1, 0x9afdbc82);
+ TestInt32Unop(execution_mode, kExprI32Ctz, 0, 0x9afdbc81);
}
WASM_EXEC_TEST(Int32Popcnt) {
- TestInt32Unop(kExprI32Popcnt, 32, 0xffffffff);
- TestInt32Unop(kExprI32Popcnt, 0, 0x00000000);
- TestInt32Unop(kExprI32Popcnt, 1, 0x00008000);
- TestInt32Unop(kExprI32Popcnt, 13, 0x12345678);
- TestInt32Unop(kExprI32Popcnt, 19, 0xfedcba09);
+ TestInt32Unop(execution_mode, kExprI32Popcnt, 32, 0xffffffff);
+ TestInt32Unop(execution_mode, kExprI32Popcnt, 0, 0x00000000);
+ TestInt32Unop(execution_mode, kExprI32Popcnt, 1, 0x00008000);
+ TestInt32Unop(execution_mode, kExprI32Popcnt, 13, 0x12345678);
+ TestInt32Unop(execution_mode, kExprI32Popcnt, 19, 0xfedcba09);
}
WASM_EXEC_TEST(I32Eqz) {
- TestInt32Unop(kExprI32Eqz, 0, 1);
- TestInt32Unop(kExprI32Eqz, 0, -1);
- TestInt32Unop(kExprI32Eqz, 0, -827343);
- TestInt32Unop(kExprI32Eqz, 0, 8888888);
- TestInt32Unop(kExprI32Eqz, 1, 0);
+ TestInt32Unop(execution_mode, kExprI32Eqz, 0, 1);
+ TestInt32Unop(execution_mode, kExprI32Eqz, 0, -1);
+ TestInt32Unop(execution_mode, kExprI32Eqz, 0, -827343);
+ TestInt32Unop(execution_mode, kExprI32Eqz, 0, 8888888);
+ TestInt32Unop(execution_mode, kExprI32Eqz, 1, 0);
}
WASM_EXEC_TEST(I32Shl) {
- WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
+ WasmRunner<uint32_t> r(execution_mode, MachineType::Uint32(),
+ MachineType::Uint32());
BUILD(r, WASM_I32_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT32_INPUTS(i) {
@@ -319,7 +326,8 @@
}
WASM_EXEC_TEST(I32Shr) {
- WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
+ WasmRunner<uint32_t> r(execution_mode, MachineType::Uint32(),
+ MachineType::Uint32());
BUILD(r, WASM_I32_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_UINT32_INPUTS(i) {
@@ -331,7 +339,8 @@
}
WASM_EXEC_TEST(I32Sar) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
+ MachineType::Int32());
BUILD(r, WASM_I32_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_INT32_INPUTS(i) {
@@ -343,7 +352,8 @@
}
WASM_EXEC_TEST(Int32DivS_trap) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
@@ -354,7 +364,8 @@
}
WASM_EXEC_TEST(Int32RemS_trap) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
@@ -365,7 +376,8 @@
}
WASM_EXEC_TEST(Int32DivU_trap) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
@@ -376,7 +388,8 @@
}
WASM_EXEC_TEST(Int32RemU_trap) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
+ MachineType::Int32());
BUILD(r, WASM_I32_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(17, r.Call(217, 100));
const int32_t kMin = std::numeric_limits<int32_t>::min();
@@ -387,10 +400,10 @@
}
WASM_EXEC_TEST(Int32DivS_byzero_const) {
- for (int8_t denom = -2; denom < 8; denom++) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ for (int8_t denom = -2; denom < 8; ++denom) {
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, WASM_I32_DIVS(WASM_GET_LOCAL(0), WASM_I8(denom)));
- for (int32_t val = -7; val < 8; val++) {
+ for (int32_t val = -7; val < 8; ++val) {
if (denom == 0) {
CHECK_TRAP(r.Call(val));
} else {
@@ -401,11 +414,11 @@
}
WASM_EXEC_TEST(Int32DivU_byzero_const) {
- for (uint32_t denom = 0xfffffffe; denom < 8; denom++) {
- WasmRunner<uint32_t> r(MachineType::Uint32());
+ for (uint32_t denom = 0xfffffffe; denom < 8; ++denom) {
+ WasmRunner<uint32_t> r(execution_mode, MachineType::Uint32());
BUILD(r, WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_I32V_1(denom)));
- for (uint32_t val = 0xfffffff0; val < 8; val++) {
+ for (uint32_t val = 0xfffffff0; val < 8; ++val) {
if (denom == 0) {
CHECK_TRAP(r.Call(val));
} else {
@@ -416,7 +429,7 @@
}
WASM_EXEC_TEST(Int32DivS_trap_effect) {
- TestingModule module;
+ TestingModule module(execution_mode);
module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module, MachineType::Int32(), MachineType::Int32());
@@ -434,32 +447,36 @@
CHECK_TRAP(r.Call(0, 0));
}
-void TestFloat32Binop(WasmOpcode opcode, int32_t expected, float a, float b) {
+void TestFloat32Binop(WasmExecutionMode execution_mode, WasmOpcode opcode,
+ int32_t expected, float a, float b) {
{
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// return K op K
BUILD(r, WASM_BINOP(opcode, WASM_F32(a), WASM_F32(b)));
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(MachineType::Float32(), MachineType::Float32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Float32(),
+ MachineType::Float32());
// return a op b
BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(expected, r.Call(a, b));
}
}
-void TestFloat32BinopWithConvert(WasmOpcode opcode, int32_t expected, float a,
+void TestFloat32BinopWithConvert(WasmExecutionMode execution_mode,
+ WasmOpcode opcode, int32_t expected, float a,
float b) {
{
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// return int(K op K)
BUILD(r,
WASM_I32_SCONVERT_F32(WASM_BINOP(opcode, WASM_F32(a), WASM_F32(b))));
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(MachineType::Float32(), MachineType::Float32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Float32(),
+ MachineType::Float32());
// return int(a op b)
BUILD(r, WASM_I32_SCONVERT_F32(
WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
@@ -467,62 +484,68 @@
}
}
-void TestFloat32UnopWithConvert(WasmOpcode opcode, int32_t expected, float a) {
+void TestFloat32UnopWithConvert(WasmExecutionMode execution_mode,
+ WasmOpcode opcode, int32_t expected, float a) {
{
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// return int(op(K))
BUILD(r, WASM_I32_SCONVERT_F32(WASM_UNOP(opcode, WASM_F32(a))));
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(MachineType::Float32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Float32());
// return int(op(a))
BUILD(r, WASM_I32_SCONVERT_F32(WASM_UNOP(opcode, WASM_GET_LOCAL(0))));
CHECK_EQ(expected, r.Call(a));
}
}
-void TestFloat64Binop(WasmOpcode opcode, int32_t expected, double a, double b) {
+void TestFloat64Binop(WasmExecutionMode execution_mode, WasmOpcode opcode,
+ int32_t expected, double a, double b) {
{
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// return K op K
BUILD(r, WASM_BINOP(opcode, WASM_F64(a), WASM_F64(b)));
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(MachineType::Float64(), MachineType::Float64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Float64(),
+ MachineType::Float64());
// return a op b
BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
CHECK_EQ(expected, r.Call(a, b));
}
}
-void TestFloat64BinopWithConvert(WasmOpcode opcode, int32_t expected, double a,
+void TestFloat64BinopWithConvert(WasmExecutionMode execution_mode,
+ WasmOpcode opcode, int32_t expected, double a,
double b) {
{
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// return int(K op K)
BUILD(r,
WASM_I32_SCONVERT_F64(WASM_BINOP(opcode, WASM_F64(a), WASM_F64(b))));
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(MachineType::Float64(), MachineType::Float64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Float64(),
+ MachineType::Float64());
BUILD(r, WASM_I32_SCONVERT_F64(
WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
CHECK_EQ(expected, r.Call(a, b));
}
}
-void TestFloat64UnopWithConvert(WasmOpcode opcode, int32_t expected, double a) {
+void TestFloat64UnopWithConvert(WasmExecutionMode execution_mode,
+ WasmOpcode opcode, int32_t expected, double a) {
{
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// return int(op(K))
BUILD(r, WASM_I32_SCONVERT_F64(WASM_UNOP(opcode, WASM_F64(a))));
CHECK_EQ(expected, r.Call());
}
{
- WasmRunner<int32_t> r(MachineType::Float64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Float64());
// return int(op(a))
BUILD(r, WASM_I32_SCONVERT_F64(WASM_UNOP(opcode, WASM_GET_LOCAL(0))));
CHECK_EQ(expected, r.Call(a));
@@ -530,49 +553,50 @@
}
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);
- TestFloat32Binop(kExprF32Le, 1, -1111.0f, -1111.0f);
- TestFloat32Binop(kExprF32Gt, 1, -9.0f, -9.5f);
- TestFloat32Binop(kExprF32Ge, 1, -1111.0f, -1111.0f);
+ TestFloat32Binop(execution_mode, kExprF32Eq, 1, 8.125f, 8.125f);
+ TestFloat32Binop(execution_mode, kExprF32Ne, 1, 8.125f, 8.127f);
+ TestFloat32Binop(execution_mode, kExprF32Lt, 1, -9.5f, -9.0f);
+ TestFloat32Binop(execution_mode, kExprF32Le, 1, -1111.0f, -1111.0f);
+ TestFloat32Binop(execution_mode, kExprF32Gt, 1, -9.0f, -9.5f);
+ TestFloat32Binop(execution_mode, kExprF32Ge, 1, -1111.0f, -1111.0f);
- TestFloat32BinopWithConvert(kExprF32Add, 10, 3.5f, 6.5f);
- TestFloat32BinopWithConvert(kExprF32Sub, 2, 44.5f, 42.5f);
- TestFloat32BinopWithConvert(kExprF32Mul, -66, -132.1f, 0.5f);
- TestFloat32BinopWithConvert(kExprF32Div, 11, 22.1f, 2.0f);
+ TestFloat32BinopWithConvert(execution_mode, kExprF32Add, 10, 3.5f, 6.5f);
+ TestFloat32BinopWithConvert(execution_mode, kExprF32Sub, 2, 44.5f, 42.5f);
+ TestFloat32BinopWithConvert(execution_mode, kExprF32Mul, -66, -132.1f, 0.5f);
+ TestFloat32BinopWithConvert(execution_mode, kExprF32Div, 11, 22.1f, 2.0f);
}
WASM_EXEC_TEST(Float32Unops) {
- TestFloat32UnopWithConvert(kExprF32Abs, 8, 8.125f);
- TestFloat32UnopWithConvert(kExprF32Abs, 9, -9.125f);
- TestFloat32UnopWithConvert(kExprF32Neg, -213, 213.125f);
- TestFloat32UnopWithConvert(kExprF32Sqrt, 12, 144.4f);
+ TestFloat32UnopWithConvert(execution_mode, kExprF32Abs, 8, 8.125f);
+ TestFloat32UnopWithConvert(execution_mode, kExprF32Abs, 9, -9.125f);
+ TestFloat32UnopWithConvert(execution_mode, kExprF32Neg, -213, 213.125f);
+ TestFloat32UnopWithConvert(execution_mode, kExprF32Sqrt, 12, 144.4f);
}
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);
- TestFloat64Binop(kExprF64Le, 1, -88.9, -88.9);
- TestFloat64Binop(kExprF64Gt, 1, 11.7, -32.4);
- TestFloat64Binop(kExprF64Ge, 1, -88.9, -88.9);
+ TestFloat64Binop(execution_mode, kExprF64Eq, 1, 16.25, 16.25);
+ TestFloat64Binop(execution_mode, kExprF64Ne, 1, 16.25, 16.15);
+ TestFloat64Binop(execution_mode, kExprF64Lt, 1, -32.4, 11.7);
+ TestFloat64Binop(execution_mode, kExprF64Le, 1, -88.9, -88.9);
+ TestFloat64Binop(execution_mode, kExprF64Gt, 1, 11.7, -32.4);
+ TestFloat64Binop(execution_mode, kExprF64Ge, 1, -88.9, -88.9);
- TestFloat64BinopWithConvert(kExprF64Add, 100, 43.5, 56.5);
- TestFloat64BinopWithConvert(kExprF64Sub, 200, 12200.1, 12000.1);
- TestFloat64BinopWithConvert(kExprF64Mul, -33, 134, -0.25);
- TestFloat64BinopWithConvert(kExprF64Div, -1111, -2222.3, 2);
+ TestFloat64BinopWithConvert(execution_mode, kExprF64Add, 100, 43.5, 56.5);
+ TestFloat64BinopWithConvert(execution_mode, kExprF64Sub, 200, 12200.1,
+ 12000.1);
+ TestFloat64BinopWithConvert(execution_mode, kExprF64Mul, -33, 134, -0.25);
+ TestFloat64BinopWithConvert(execution_mode, kExprF64Div, -1111, -2222.3, 2);
}
WASM_EXEC_TEST(Float64Unops) {
- TestFloat64UnopWithConvert(kExprF64Abs, 108, 108.125);
- TestFloat64UnopWithConvert(kExprF64Abs, 209, -209.125);
- TestFloat64UnopWithConvert(kExprF64Neg, -209, 209.125);
- TestFloat64UnopWithConvert(kExprF64Sqrt, 13, 169.4);
+ TestFloat64UnopWithConvert(execution_mode, kExprF64Abs, 108, 108.125);
+ TestFloat64UnopWithConvert(execution_mode, kExprF64Abs, 209, -209.125);
+ TestFloat64UnopWithConvert(execution_mode, kExprF64Neg, -209, 209.125);
+ TestFloat64UnopWithConvert(execution_mode, kExprF64Sqrt, 13, 169.4);
}
WASM_EXEC_TEST(Float32Neg) {
- WasmRunner<float> r(MachineType::Float32());
+ WasmRunner<float> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_F32_NEG(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -582,22 +606,47 @@
}
WASM_EXEC_TEST(Float32SubMinusZero) {
- WasmRunner<float> r(MachineType::Float32());
+ WasmRunner<float> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_F32_SUB(WASM_F32(-0.0), WASM_GET_LOCAL(0)));
- CHECK_EQ(0x7fe00000, bit_cast<uint32_t>(r.Call(bit_cast<float>(0x7fa00000))));
+ uint32_t sNanValue =
+ bit_cast<uint32_t>(std::numeric_limits<float>::signaling_NaN());
+ uint32_t qNanValue =
+ bit_cast<uint32_t>(std::numeric_limits<float>::quiet_NaN());
+ uint32_t payload = 0x00200000;
+
+ uint32_t expected = (qNanValue & 0xffc00000) | payload;
+ uint32_t operand = (sNanValue & 0xffc00000) | payload;
+ CHECK_EQ(expected, bit_cast<uint32_t>(r.Call(bit_cast<float>(operand))));
+
+ // Change the sign of the NaN.
+ expected |= 0x80000000;
+ operand |= 0x80000000;
+ CHECK_EQ(expected, bit_cast<uint32_t>(r.Call(bit_cast<float>(operand))));
}
WASM_EXEC_TEST(Float64SubMinusZero) {
- WasmRunner<double> r(MachineType::Float64());
+ WasmRunner<double> r(execution_mode, 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))));
+ uint64_t sNanValue =
+ bit_cast<uint64_t>(std::numeric_limits<double>::signaling_NaN());
+ uint64_t qNanValue =
+ bit_cast<uint64_t>(std::numeric_limits<double>::quiet_NaN());
+ uint64_t payload = 0x0000123456789abc;
+
+ uint64_t expected = (qNanValue & 0xfff8000000000000) | payload;
+ uint64_t operand = (sNanValue & 0xfff8000000000000) | payload;
+ CHECK_EQ(expected, bit_cast<uint64_t>(r.Call(bit_cast<double>(operand))));
+
+ // Change the sign of the NaN.
+ expected |= 0x8000000000000000;
+ operand |= 0x8000000000000000;
+ CHECK_EQ(expected, bit_cast<uint64_t>(r.Call(bit_cast<double>(operand))));
}
WASM_EXEC_TEST(Float64Neg) {
- WasmRunner<double> r(MachineType::Float64());
+ WasmRunner<double> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_F64_NEG(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -607,7 +656,7 @@
}
WASM_EXEC_TEST(IfElse_P) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// if (p0) return 11; else return 22;
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
WASM_I8(11), // --
@@ -619,33 +668,37 @@
}
WASM_EXEC_TEST(If_empty1) {
- WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
+ WasmRunner<uint32_t> r(execution_mode, 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)); }
}
WASM_EXEC_TEST(IfElse_empty1) {
- WasmRunner<uint32_t> r(MachineType::Uint32(), MachineType::Uint32());
+ WasmRunner<uint32_t> r(execution_mode, 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());
+ WasmRunner<uint32_t> r(execution_mode, 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());
+ WasmRunner<uint32_t> r(execution_mode, 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());
+ WasmRunner<int32_t> r(execution_mode, 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));
@@ -653,7 +706,8 @@
}
WASM_EXEC_TEST(If_chain_set) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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))),
@@ -665,7 +719,7 @@
}
WASM_EXEC_TEST(IfElse_Unreachable1) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
// if (0) unreachable; else return 22;
BUILD(r, WASM_IF_ELSE(WASM_ZERO, // --
WASM_UNREACHABLE, // --
@@ -674,21 +728,21 @@
}
WASM_EXEC_TEST(Return12) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
BUILD(r, RET_I8(12));
CHECK_EQ(12, r.Call());
}
WASM_EXEC_TEST(Return17) {
- WasmRunner<int32_t> r;
+ WasmRunner<int32_t> r(execution_mode);
BUILD(r, B1(RET_I8(17)));
CHECK_EQ(17, r.Call());
}
WASM_EXEC_TEST(Return_I32) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, RET(WASM_GET_LOCAL(0)));
@@ -696,7 +750,7 @@
}
WASM_EXEC_TEST(Return_F32) {
- WasmRunner<float> r(MachineType::Float32());
+ WasmRunner<float> r(execution_mode, MachineType::Float32());
BUILD(r, RET(WASM_GET_LOCAL(0)));
@@ -712,7 +766,7 @@
}
WASM_EXEC_TEST(Return_F64) {
- WasmRunner<double> r(MachineType::Float64());
+ WasmRunner<double> r(execution_mode, MachineType::Float64());
BUILD(r, RET(WASM_GET_LOCAL(0)));
@@ -728,7 +782,7 @@
}
WASM_EXEC_TEST(Select) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// return select(11, 22, a);
BUILD(r, WASM_SELECT(WASM_I8(11), WASM_I8(22), WASM_GET_LOCAL(0)));
FOR_INT32_INPUTS(i) {
@@ -738,7 +792,7 @@
}
WASM_EXEC_TEST(Select_strict1) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// select(a=0, a=1, a=2); return a
BUILD(r, B2(WASM_SELECT(WASM_SET_LOCAL(0, WASM_I8(0)),
WASM_SET_LOCAL(0, WASM_I8(1)),
@@ -748,7 +802,7 @@
}
WASM_EXEC_TEST(Select_strict2) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
r.AllocateLocal(kAstI32);
r.AllocateLocal(kAstI32);
// select(b=5, c=6, a)
@@ -761,7 +815,7 @@
}
WASM_EXEC_TEST(Select_strict3) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
r.AllocateLocal(kAstI32);
r.AllocateLocal(kAstI32);
// select(b=5, c=6, a=b)
@@ -775,7 +829,7 @@
}
WASM_EXEC_TEST(BrIf_strict) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(
r,
B2(B1(WASM_BRV_IF(0, WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_I8(99)))),
@@ -785,14 +839,14 @@
}
WASM_EXEC_TEST(BrTable0a) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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)); }
}
WASM_EXEC_TEST(BrTable0b) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r,
B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 1, BR_TARGET(0), BR_TARGET(0))),
WASM_I8(92)));
@@ -800,7 +854,7 @@
}
WASM_EXEC_TEST(BrTable0c) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(
r,
B2(B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 1, BR_TARGET(0), BR_TARGET(1))),
@@ -813,13 +867,13 @@
}
WASM_EXEC_TEST(BrTable1) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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)); }
}
WASM_EXEC_TEST(BrTable_loop) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r,
B2(WASM_LOOP(1, WASM_BR_TABLE(WASM_INC_LOCAL_BY(0, 1), 2, BR_TARGET(2),
BR_TARGET(1), BR_TARGET(0))),
@@ -833,7 +887,7 @@
}
WASM_EXEC_TEST(BrTable_br) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r,
B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 1, BR_TARGET(1), BR_TARGET(0))),
RET_I8(91)),
@@ -845,7 +899,7 @@
}
WASM_EXEC_TEST(BrTable_br2) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, B2(B2(B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 3, BR_TARGET(1),
BR_TARGET(2), BR_TARGET(3), BR_TARGET(0))),
@@ -862,8 +916,8 @@
}
WASM_EXEC_TEST(BrTable4) {
- for (int i = 0; i < 4; i++) {
- for (int t = 0; t < 4; t++) {
+ for (int i = 0; i < 4; ++i) {
+ for (int t = 0; t < 4; ++t) {
uint32_t cases[] = {0, 1, 2, 3};
cases[i] = t;
byte code[] = {B2(B2(B2(B2(B1(WASM_BR_TABLE(
@@ -876,10 +930,10 @@
RET_I8(73)),
WASM_I8(75)};
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
r.Build(code, code + arraysize(code));
- for (int x = -3; x < 50; x++) {
+ for (int x = -3; x < 50; ++x) {
int index = (x > 3 || x < 0) ? 3 : x;
int32_t expected = 70 + cases[index];
CHECK_EQ(expected, r.Call(x));
@@ -889,11 +943,11 @@
}
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++) {
- for (byte d = 0; d < 4; d++) {
- for (int i = 0; i < 4; i++) {
+ for (byte a = 0; a < 4; ++a) {
+ for (byte b = 0; b < 4; ++b) {
+ for (byte c = 0; c < 4; ++c) {
+ for (byte d = 0; d < 4; ++d) {
+ for (int i = 0; i < 4; ++i) {
uint32_t cases[] = {a, b, c, d};
byte code[] = {
B2(B2(B2(B2(B1(WASM_BR_TABLE(
@@ -906,10 +960,10 @@
RET_I8(53)),
WASM_I8(55)};
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
r.Build(code, code + arraysize(code));
- for (int x = -6; x < 47; x++) {
+ for (int x = -6; x < 47; ++x) {
int index = (x > 3 || x < 0) ? 3 : x;
int32_t expected = 50 + cases[index];
CHECK_EQ(expected, r.Call(x));
@@ -931,7 +985,8 @@
WASM_INC_LOCAL_BY(1, 8)),
WASM_GET_LOCAL(1)};
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
+ MachineType::Int32());
r.Build(code, code + arraysize(code));
CHECK_EQ(15, r.Call(0, 0));
@@ -948,7 +1003,7 @@
}
WASM_EXEC_TEST(F32ReinterpretI32) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module);
@@ -963,7 +1018,7 @@
}
WASM_EXEC_TEST(I32ReinterpretF32) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module, MachineType::Int32());
@@ -980,7 +1035,7 @@
}
WASM_EXEC_TEST(ReturnStore) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module);
@@ -999,7 +1054,7 @@
// Build the test function.
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t(sigs.v_v(), &module);
BUILD(t, kExprNop);
uint32_t index = t.CompileAndAdd();
@@ -1017,7 +1072,7 @@
// We use a wrapper function because WasmRunner<void> does not exist.
// Build the test function.
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t(sigs.v_v(), &module);
BUILD(t, WASM_RETURN0);
uint32_t index = t.CompileAndAdd();
@@ -1032,37 +1087,38 @@
}
WASM_EXEC_TEST(Block_empty) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, kExprBlock, kExprEnd, WASM_GET_LOCAL(0));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
}
WASM_EXEC_TEST(Block_empty_br1) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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());
+ WasmRunner<int32_t> r(execution_mode, 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());
+ WasmRunner<uint32_t> r(execution_mode, 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());
+ WasmRunner<int32_t> r(execution_mode, 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());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// { if (p0) return 51; return 52; }
BUILD(r, B2( // --
WASM_IF(WASM_GET_LOCAL(0), // --
@@ -1075,31 +1131,32 @@
}
WASM_EXEC_TEST(Loop_empty) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, kExprLoop, kExprEnd, WASM_GET_LOCAL(0));
FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
}
WASM_EXEC_TEST(Loop_empty_br1) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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());
+ WasmRunner<int32_t> r(execution_mode, 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());
+ WasmRunner<uint32_t> r(execution_mode, 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());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, B2(WASM_BRV_IF(0, WASM_I8(51), WASM_GET_LOCAL(0)), WASM_I8(52)));
FOR_INT32_INPUTS(i) {
int32_t expected = *i ? 51 : 52;
@@ -1108,7 +1165,7 @@
}
WASM_EXEC_TEST(Block_IfElse_P_assign) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// { if (p0) p0 = 71; else p0 = 72; return p0; }
BUILD(r, B2( // --
WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
@@ -1122,7 +1179,7 @@
}
WASM_EXEC_TEST(Block_IfElse_P_return) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// if (p0) return 81; else return 82;
BUILD(r, // --
WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
@@ -1135,7 +1192,7 @@
}
WASM_EXEC_TEST(Block_If_P_assign) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// { if (p0) p0 = 61; p0; }
BUILD(r, WASM_BLOCK(
2, WASM_IF(WASM_GET_LOCAL(0), WASM_SET_LOCAL(0, WASM_I8(61))),
@@ -1147,14 +1204,14 @@
}
WASM_EXEC_TEST(DanglingAssign) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// { return 0; p0 = 0; }
BUILD(r, B2(RET_I8(99), WASM_SET_LOCAL(0, WASM_ZERO)));
CHECK_EQ(99, r.Call(1));
}
WASM_EXEC_TEST(ExprIf_P) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// p0 ? 11 : 22;
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
WASM_I8(11), // --
@@ -1166,7 +1223,7 @@
}
WASM_EXEC_TEST(ExprIf_P_fallthru) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// p0 ? 11 : 22;
BUILD(r, WASM_IF_ELSE(WASM_GET_LOCAL(0), // --
WASM_I8(11), // --
@@ -1178,7 +1235,7 @@
}
WASM_EXEC_TEST(CountDown) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r,
WASM_BLOCK(
2, WASM_LOOP(
@@ -1193,7 +1250,7 @@
}
WASM_EXEC_TEST(CountDown_fallthru) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r,
WASM_BLOCK(
2, WASM_LOOP(3, WASM_IF(WASM_NOT(WASM_GET_LOCAL(0)), WASM_BREAK(1)),
@@ -1207,7 +1264,7 @@
}
WASM_EXEC_TEST(WhileCountDown) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, WASM_BLOCK(
2, WASM_WHILE(WASM_GET_LOCAL(0),
WASM_SET_LOCAL(0, WASM_I32_SUB(WASM_GET_LOCAL(0),
@@ -1219,7 +1276,7 @@
}
WASM_EXEC_TEST(Loop_if_break1) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
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)));
@@ -1230,7 +1287,7 @@
}
WASM_EXEC_TEST(Loop_if_break2) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, B2(WASM_LOOP(2, WASM_BR_IF(1, WASM_GET_LOCAL(0)),
WASM_SET_LOCAL(0, WASM_I8(99))),
WASM_GET_LOCAL(0)));
@@ -1241,7 +1298,7 @@
}
WASM_EXEC_TEST(Loop_if_break_fallthru) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, B1(WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BREAK(1)),
WASM_SET_LOCAL(0, WASM_I8(93)))),
WASM_GET_LOCAL(0));
@@ -1252,7 +1309,7 @@
}
WASM_EXEC_TEST(IfBreak1) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
@@ -1261,7 +1318,7 @@
}
WASM_EXEC_TEST(IfBreak2) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
@@ -1270,7 +1327,7 @@
}
WASM_EXEC_TEST(LoadMemI32) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module, MachineType::Int32());
module.RandomizeMemory(1111);
@@ -1287,8 +1344,29 @@
CHECK_EQ(77777777, r.Call(0));
}
+WASM_EXEC_TEST(LoadMemI32_alignment) {
+ TestingModule module(execution_mode);
+ int32_t* memory = module.AddMemoryElems<int32_t>(8);
+ for (byte alignment = 0; alignment <= 2; ++alignment) {
+ WasmRunner<int32_t> r(&module, MachineType::Int32());
+ module.RandomizeMemory(1111);
+
+ BUILD(r,
+ WASM_LOAD_MEM_ALIGNMENT(MachineType::Int32(), WASM_I8(0), alignment));
+
+ memory[0] = 0x1a2b3c4d;
+ CHECK_EQ(0x1a2b3c4d, r.Call(0));
+
+ memory[0] = 0x5e6f7a8b;
+ CHECK_EQ(0x5e6f7a8b, r.Call(0));
+
+ memory[0] = 0x9ca0b1c2;
+ CHECK_EQ(0x9ca0b1c2, r.Call(0));
+ }
+}
+
WASM_EXEC_TEST(LoadMemI32_oob) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* memory = module.AddMemoryElems<int32_t>(8);
WasmRunner<int32_t> r(&module, MachineType::Uint32());
module.RandomizeMemory(1111);
@@ -1297,17 +1375,17 @@
memory[0] = 88888888;
CHECK_EQ(88888888, r.Call(0u));
- for (uint32_t offset = 29; offset < 40; offset++) {
+ for (uint32_t offset = 29; offset < 40; ++offset) {
CHECK_TRAP(r.Call(offset));
}
- for (uint32_t offset = 0x80000000; offset < 0x80000010; offset++) {
+ for (uint32_t offset = 0x80000000; offset < 0x80000010; ++offset) {
CHECK_TRAP(r.Call(offset));
}
}
WASM_EXEC_TEST(LoadMem_offset_oob) {
- TestingModule module;
+ TestingModule module(execution_mode);
module.AddMemoryElems<int32_t>(8);
static const MachineType machineTypes[] = {
@@ -1316,7 +1394,7 @@
MachineType::Int64(), MachineType::Uint64(), MachineType::Float32(),
MachineType::Float64()};
- for (size_t m = 0; m < arraysize(machineTypes); m++) {
+ for (size_t m = 0; m < arraysize(machineTypes); ++m) {
module.RandomizeMemory(1116 + static_cast<int>(m));
WasmRunner<int32_t> r(&module, MachineType::Uint32());
uint32_t boundary = 24 - WasmOpcodes::MemSize(machineTypes[m]);
@@ -1326,14 +1404,14 @@
CHECK_EQ(0, r.Call(boundary)); // in bounds.
- for (uint32_t offset = boundary + 1; offset < boundary + 19; offset++) {
+ for (uint32_t offset = boundary + 1; offset < boundary + 19; ++offset) {
CHECK_TRAP(r.Call(offset)); // out of bounds.
}
}
}
WASM_EXEC_TEST(LoadMemI32_offset) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* memory = module.AddMemoryElems<int32_t>(4);
WasmRunner<int32_t> r(&module, MachineType::Int32());
module.RandomizeMemory(1111);
@@ -1357,14 +1435,12 @@
CHECK_EQ(44444444, r.Call(8));
}
-#if !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
-
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++) {
- for (int index = 0; index < kMemSize + 5; index++) {
- TestingModule module;
+ for (int offset = 0; offset < kMemSize + 5; ++offset) {
+ for (int index = 0; index < kMemSize + 5; ++index) {
+ TestingModule module(execution_mode);
module.AddMemoryElems<byte>(kMemSize);
WasmRunner<int32_t> r(&module);
@@ -1382,13 +1458,11 @@
}
}
-#endif
-
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) {
- TestingModule module;
+ TestingModule module(execution_mode);
module.AddMemoryElems<byte>(kMemSize);
WasmRunner<int32_t> r(&module);
@@ -1406,8 +1480,25 @@
}
}
+WASM_EXEC_TEST(StoreMemI32_alignment) {
+ TestingModule module(execution_mode);
+ int32_t* memory = module.AddMemoryElems<int32_t>(4);
+ const int32_t kWritten = 0x12345678;
+
+ for (byte i = 0; i <= 2; ++i) {
+ WasmRunner<int32_t> r(&module, MachineType::Int32());
+ BUILD(r, WASM_STORE_MEM_ALIGNMENT(MachineType::Int32(), WASM_ZERO, i,
+ WASM_GET_LOCAL(0)));
+ module.RandomizeMemory(1111);
+ memory[0] = 0;
+
+ CHECK_EQ(kWritten, r.Call(kWritten));
+ CHECK_EQ(kWritten, memory[0]);
+ }
+}
+
WASM_EXEC_TEST(StoreMemI32_offset) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* memory = module.AddMemoryElems<int32_t>(4);
WasmRunner<int32_t> r(&module, MachineType::Int32());
const int32_t kWritten = 0xaabbccdd;
@@ -1415,7 +1506,7 @@
BUILD(r, WASM_STORE_MEM_OFFSET(MachineType::Int32(), 4, WASM_GET_LOCAL(0),
WASM_I32V_5(kWritten)));
- for (int i = 0; i < 2; i++) {
+ for (int i = 0; i < 2; ++i) {
module.RandomizeMemory(1111);
memory[0] = 66666666;
memory[1] = 77777777;
@@ -1430,23 +1521,16 @@
}
WASM_EXEC_TEST(StoreMem_offset_oob) {
- TestingModule module;
+ TestingModule module(execution_mode);
byte* memory = module.AddMemoryElems<byte>(32);
-#if WASM_64
- static const MachineType machineTypes[] = {
- MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(),
- MachineType::Uint16(), MachineType::Int32(), MachineType::Uint32(),
- MachineType::Int64(), MachineType::Uint64(), MachineType::Float32(),
- MachineType::Float64()};
-#else
+ // 64-bit cases are handled in test-run-wasm-64.cc
static const MachineType machineTypes[] = {
MachineType::Int8(), MachineType::Uint8(), MachineType::Int16(),
MachineType::Uint16(), MachineType::Int32(), MachineType::Uint32(),
MachineType::Float32(), MachineType::Float64()};
-#endif
- for (size_t m = 0; m < arraysize(machineTypes); m++) {
+ for (size_t m = 0; m < arraysize(machineTypes); ++m) {
module.RandomizeMemory(1119 + static_cast<int>(m));
WasmRunner<int32_t> r(&module, MachineType::Uint32());
@@ -1459,7 +1543,7 @@
CHECK_EQ(0, r.Call(boundary)); // in bounds.
CHECK_EQ(0, memcmp(&memory[0], &memory[8 + boundary], memsize));
- for (uint32_t offset = boundary + 1; offset < boundary + 19; offset++) {
+ for (uint32_t offset = boundary + 1; offset < boundary + 19; ++offset) {
CHECK_TRAP(r.Call(offset)); // out of bounds.
}
}
@@ -1467,21 +1551,21 @@
WASM_EXEC_TEST(LoadMemI32_P) {
const int kNumElems = 8;
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* memory = module.AddMemoryElems<int32_t>(kNumElems);
WasmRunner<int32_t> r(&module, MachineType::Int32());
module.RandomizeMemory(2222);
BUILD(r, WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0)));
- for (int i = 0; i < kNumElems; i++) {
+ for (int i = 0; i < kNumElems; ++i) {
CHECK_EQ(memory[i], r.Call(i * 4));
}
}
WASM_EXEC_TEST(MemI32_Sum) {
const int kNumElems = 20;
- TestingModule module;
+ TestingModule module(execution_mode);
uint32_t* memory = module.AddMemoryElems<uint32_t>(kNumElems);
WasmRunner<uint32_t> r(&module, MachineType::Int32());
const byte kSum = r.AllocateLocal(kAstI32);
@@ -1500,20 +1584,20 @@
WASM_GET_LOCAL(1)));
// Run 4 trials.
- for (int i = 0; i < 3; i++) {
+ for (int i = 0; i < 3; ++i) {
module.RandomizeMemory(i * 33);
uint32_t expected = 0;
- for (size_t j = kNumElems - 1; j > 0; j--) {
+ for (size_t j = kNumElems - 1; j > 0; --j) {
expected += memory[j];
}
- uint32_t result = r.Call(static_cast<int>(4 * (kNumElems - 1)));
+ uint32_t result = r.Call(4 * (kNumElems - 1));
CHECK_EQ(expected, result);
}
}
WASM_EXEC_TEST(CheckMachIntsZero) {
const int kNumElems = 55;
- TestingModule module;
+ TestingModule module(execution_mode);
module.AddMemoryElems<uint32_t>(kNumElems);
WasmRunner<uint32_t> r(&module, MachineType::Int32());
@@ -1528,7 +1612,7 @@
WASM_EXEC_TEST(MemF32_Sum) {
const int kSize = 5;
- TestingModule module;
+ TestingModule module(execution_mode);
module.AddMemoryElems<float>(kSize);
float* buffer = module.raw_mem_start<float>();
buffer[0] = -99.25;
@@ -1560,11 +1644,12 @@
}
template <typename T>
-T GenerateAndRunFold(WasmOpcode binop, T* buffer, size_t size,
- LocalType astType, MachineType memType) {
- TestingModule module;
+T GenerateAndRunFold(WasmExecutionMode execution_mode, WasmOpcode binop,
+ T* buffer, uint32_t size, LocalType astType,
+ MachineType memType) {
+ TestingModule module(execution_mode);
module.AddMemoryElems<T>(size);
- for (size_t i = 0; i < size; i++) {
+ for (uint32_t i = 0; i < size; ++i) {
module.raw_mem_start<T>()[i] = buffer[i];
}
WasmRunner<int32_t> r(&module, MachineType::Int32());
@@ -1592,19 +1677,20 @@
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,
- kAstF64, MachineType::Float64());
+ double result =
+ GenerateAndRunFold<double>(execution_mode, kExprF64Mul, buffer, kSize,
+ kAstF64, MachineType::Float64());
CHECK_EQ(32, result);
}
-TEST(Build_Wasm_Infinite_Loop) {
- WasmRunner<int32_t> r(MachineType::Int32());
+WASM_EXEC_TEST(Build_Wasm_Infinite_Loop) {
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
// Only build the graph and compile, don't run.
BUILD(r, WASM_INFINITE_LOOP);
}
-TEST(Build_Wasm_Infinite_Loop_effect) {
- TestingModule module;
+WASM_EXEC_TEST(Build_Wasm_Infinite_Loop_effect) {
+ TestingModule module(execution_mode);
module.AddMemoryElems<int8_t>(16);
WasmRunner<int32_t> r(&module, MachineType::Int32());
@@ -1613,47 +1699,47 @@
}
WASM_EXEC_TEST(Unreachable0a) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
}
WASM_EXEC_TEST(Unreachable0b) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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());
+ WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
BUILD(r, WASM_UNREACHABLE);
}
TEST(Build_Wasm_Unreachable2) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
BUILD(r, WASM_UNREACHABLE, WASM_UNREACHABLE);
}
TEST(Build_Wasm_Unreachable3) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
BUILD(r, WASM_UNREACHABLE, WASM_UNREACHABLE, WASM_UNREACHABLE);
}
TEST(Build_Wasm_UnreachableIf1) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(kExecuteCompiled, 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());
+ WasmRunner<int32_t> r(kExecuteCompiled, MachineType::Int32());
BUILD(r, WASM_UNREACHABLE,
WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_UNREACHABLE));
}
WASM_EXEC_TEST(Unreachable_Load) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, B2(WASM_BRV(0, WASM_GET_LOCAL(0)),
WASM_LOAD_MEM(MachineType::Int8(), WASM_GET_LOCAL(0))));
CHECK_EQ(11, r.Call(11));
@@ -1661,14 +1747,14 @@
}
WASM_EXEC_TEST(Infinite_Loop_not_taken1) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
}
WASM_EXEC_TEST(Infinite_Loop_not_taken2) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
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.
@@ -1676,7 +1762,7 @@
}
WASM_EXEC_TEST(Infinite_Loop_not_taken2_brif) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r,
B2(WASM_BRV_IF(0, WASM_I8(45), WASM_GET_LOCAL(0)), WASM_INFINITE_LOOP));
// Run the code, but don't go into the infinite loop.
@@ -1719,7 +1805,7 @@
}
WASM_EXEC_TEST(Int32LoadInt8_signext) {
- TestingModule module;
+ TestingModule module(execution_mode);
const int kNumElems = 16;
int8_t* memory = module.AddMemoryElems<int8_t>(kNumElems);
module.RandomizeMemory();
@@ -1727,13 +1813,13 @@
WasmRunner<int32_t> r(&module, MachineType::Int32());
BUILD(r, WASM_LOAD_MEM(MachineType::Int8(), WASM_GET_LOCAL(0)));
- for (size_t i = 0; i < kNumElems; i++) {
- CHECK_EQ(memory[i], r.Call(static_cast<int>(i)));
+ for (int i = 0; i < kNumElems; ++i) {
+ CHECK_EQ(memory[i], r.Call(i));
}
}
WASM_EXEC_TEST(Int32LoadInt8_zeroext) {
- TestingModule module;
+ TestingModule module(execution_mode);
const int kNumElems = 16;
byte* memory = module.AddMemory(kNumElems);
module.RandomizeMemory(77);
@@ -1741,13 +1827,13 @@
WasmRunner<int32_t> r(&module, MachineType::Int32());
BUILD(r, WASM_LOAD_MEM(MachineType::Uint8(), WASM_GET_LOCAL(0)));
- for (size_t i = 0; i < kNumElems; i++) {
- CHECK_EQ(memory[i], r.Call(static_cast<int>(i)));
+ for (int i = 0; i < kNumElems; ++i) {
+ CHECK_EQ(memory[i], r.Call(i));
}
}
WASM_EXEC_TEST(Int32LoadInt16_signext) {
- TestingModule module;
+ TestingModule module(execution_mode);
const int kNumBytes = 16;
byte* memory = module.AddMemory(kNumBytes);
module.RandomizeMemory(888);
@@ -1755,14 +1841,14 @@
WasmRunner<int32_t> r(&module, MachineType::Int32());
BUILD(r, WASM_LOAD_MEM(MachineType::Int16(), WASM_GET_LOCAL(0)));
- for (size_t i = 0; i < kNumBytes; i += 2) {
+ for (int i = 0; i < kNumBytes; i += 2) {
int32_t expected = memory[i] | (static_cast<int8_t>(memory[i + 1]) << 8);
- CHECK_EQ(expected, r.Call(static_cast<int>(i)));
+ CHECK_EQ(expected, r.Call(i));
}
}
WASM_EXEC_TEST(Int32LoadInt16_zeroext) {
- TestingModule module;
+ TestingModule module(execution_mode);
const int kNumBytes = 16;
byte* memory = module.AddMemory(kNumBytes);
module.RandomizeMemory(9999);
@@ -1770,14 +1856,14 @@
WasmRunner<int32_t> r(&module, MachineType::Int32());
BUILD(r, WASM_LOAD_MEM(MachineType::Uint16(), WASM_GET_LOCAL(0)));
- for (size_t i = 0; i < kNumBytes; i += 2) {
+ for (int i = 0; i < kNumBytes; i += 2) {
int32_t expected = memory[i] | (memory[i + 1] << 8);
- CHECK_EQ(expected, r.Call(static_cast<int>(i)));
+ CHECK_EQ(expected, r.Call(i));
}
}
WASM_EXEC_TEST(Int32Global) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* global = module.AddGlobal<int32_t>(MachineType::Int32());
WasmRunner<int32_t> r(&module, MachineType::Int32());
// global = global + p0
@@ -1794,12 +1880,12 @@
WASM_EXEC_TEST(Int32Globals_DontAlias) {
const int kNumGlobals = 3;
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* globals[] = {module.AddGlobal<int32_t>(MachineType::Int32()),
module.AddGlobal<int32_t>(MachineType::Int32()),
module.AddGlobal<int32_t>(MachineType::Int32())};
- for (int g = 0; g < kNumGlobals; g++) {
+ for (int g = 0; g < kNumGlobals; ++g) {
// global = global + p0
WasmRunner<int32_t> r(&module, MachineType::Int32());
BUILD(r, WASM_STORE_GLOBAL(
@@ -1810,9 +1896,9 @@
int32_t before[kNumGlobals];
for (int i = 9; i < 444444; i += 111113) {
int32_t sum = *globals[g] + i;
- for (int j = 0; j < kNumGlobals; j++) before[j] = *globals[j];
+ for (int j = 0; j < kNumGlobals; ++j) before[j] = *globals[j];
r.Call(i);
- for (int j = 0; j < kNumGlobals; j++) {
+ for (int j = 0; j < kNumGlobals; ++j) {
int32_t expected = j == g ? sum : before[j];
CHECK_EQ(expected, *globals[j]);
}
@@ -1821,7 +1907,7 @@
}
WASM_EXEC_TEST(Float32Global) {
- TestingModule module;
+ TestingModule module(execution_mode);
float* global = module.AddGlobal<float>(MachineType::Float32());
WasmRunner<int32_t> r(&module, MachineType::Int32());
// global = global + p0
@@ -1839,7 +1925,7 @@
}
WASM_EXEC_TEST(Float64Global) {
- TestingModule module;
+ TestingModule module(execution_mode);
double* global = module.AddGlobal<double>(MachineType::Float64());
WasmRunner<int32_t> r(&module, MachineType::Int32());
// global = global + p0
@@ -1857,7 +1943,7 @@
}
WASM_EXEC_TEST(MixedGlobals) {
- TestingModule module;
+ TestingModule module(execution_mode);
int32_t* unused = module.AddGlobal<int32_t>(MachineType::Int32());
byte* memory = module.AddMemory(32);
@@ -1914,7 +2000,7 @@
const int32_t kExpected = -414444;
// Build the target function.
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t(sigs.i_v(), &module);
BUILD(t, WASM_I32V_3(kExpected));
uint32_t index = t.CompileAndAdd();
@@ -1930,9 +2016,9 @@
WASM_EXEC_TEST(CallF32StackParameter) {
// Build the target function.
LocalType param_types[20];
- for (int i = 0; i < 20; i++) param_types[i] = kAstF32;
+ for (int i = 0; i < 20; ++i) param_types[i] = kAstF32;
FunctionSig sig(1, 19, param_types);
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t(&sig, &module);
BUILD(t, WASM_GET_LOCAL(17));
uint32_t index = t.CompileAndAdd();
@@ -1954,9 +2040,9 @@
WASM_EXEC_TEST(CallF64StackParameter) {
// Build the target function.
LocalType param_types[20];
- for (int i = 0; i < 20; i++) param_types[i] = kAstF64;
+ for (int i = 0; i < 20; ++i) param_types[i] = kAstF64;
FunctionSig sig(1, 19, param_types);
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t(&sig, &module);
BUILD(t, WASM_GET_LOCAL(17));
uint32_t index = t.CompileAndAdd();
@@ -1981,7 +2067,7 @@
const int32_t kExpected = -414444;
// Build the target function.
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
module.AddMemory(16);
module.RandomizeMemory();
WasmFunctionCompiler t(sigs.v_v(), &module);
@@ -2002,7 +2088,7 @@
WASM_EXEC_TEST(Call_Int32Add) {
// Build the target function.
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t(sigs.i_ii(), &module);
BUILD(t, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
uint32_t index = t.CompileAndAdd();
@@ -2022,7 +2108,7 @@
WASM_EXEC_TEST(Call_Float32Sub) {
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t(sigs.f_ff(), &module);
// Build the target function.
@@ -2039,7 +2125,7 @@
}
WASM_EXEC_TEST(Call_Float64Sub) {
- TestingModule module;
+ TestingModule module(execution_mode);
double* memory = module.AddMemoryElems<double>(16);
WasmRunner<int32_t> r(&module);
@@ -2069,34 +2155,26 @@
#define ADD_CODE(vec, ...) \
do { \
byte __buf[] = {__VA_ARGS__}; \
- for (size_t i = 0; i < sizeof(__buf); i++) vec.push_back(__buf[i]); \
+ for (size_t i = 0; i < sizeof(__buf); ++i) vec.push_back(__buf[i]); \
} while (false)
-static void Run_WasmMixedCall_N(int start) {
+static void Run_WasmMixedCall_N(WasmExecutionMode execution_mode, int start) {
const int kExpected = 6333;
const int kElemSize = 8;
TestSignatures sigs;
-#if WASM_64
- static MachineType mixed[] = {
- MachineType::Int32(), MachineType::Float32(), MachineType::Int64(),
- MachineType::Float64(), MachineType::Float32(), MachineType::Int64(),
- MachineType::Int32(), MachineType::Float64(), MachineType::Float32(),
- MachineType::Float64(), MachineType::Int32(), MachineType::Int64(),
- MachineType::Int32(), MachineType::Int32()};
-#else
+ // 64-bit cases handled in test-run-wasm-64.cc.
static MachineType mixed[] = {
MachineType::Int32(), MachineType::Float32(), MachineType::Float64(),
MachineType::Float32(), MachineType::Int32(), MachineType::Float64(),
MachineType::Float32(), MachineType::Float64(), MachineType::Int32(),
MachineType::Int32(), MachineType::Int32()};
-#endif
int num_params = static_cast<int>(arraysize(mixed)) - start;
- for (int which = 0; which < num_params; which++) {
+ for (int which = 0; which < num_params; ++which) {
v8::base::AccountingAllocator allocator;
Zone zone(&allocator);
- TestingModule module;
+ TestingModule module(execution_mode);
module.AddMemory(1024);
MachineType* memtypes = &mixed[start];
MachineType result = memtypes[which];
@@ -2107,7 +2185,7 @@
uint32_t index;
FunctionSig::Builder b(&zone, 1, num_params);
b.AddReturn(WasmOpcodes::LocalTypeFor(result));
- for (int i = 0; i < num_params; i++) {
+ for (int i = 0; i < num_params; ++i) {
b.AddParam(WasmOpcodes::LocalTypeFor(memtypes[i]));
}
WasmFunctionCompiler t(b.Build(), &module);
@@ -2124,7 +2202,7 @@
ADD_CODE(code, WASM_ZERO);
// Load the arguments.
- for (int i = 0; i < num_params; i++) {
+ for (int i = 0; i < num_params; ++i) {
int offset = (i + 1) * kElemSize;
ADD_CODE(code, WASM_LOAD_MEM(memtypes[i], WASM_I8(offset)));
}
@@ -2144,12 +2222,12 @@
r.Build(&code[0], &code[0] + code.size());
// Run the code.
- for (int t = 0; t < 10; t++) {
+ for (int t = 0; t < 10; ++t) {
module.RandomizeMemory();
CHECK_EQ(kExpected, r.Call());
int size = WasmOpcodes::MemSize(result);
- for (int i = 0; i < size; i++) {
+ for (int i = 0; i < size; ++i) {
int base = (which + 1) * kElemSize;
byte expected = module.raw_mem_at<byte>(base + i);
byte result = module.raw_mem_at<byte>(i);
@@ -2159,14 +2237,14 @@
}
}
-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); }
+WASM_EXEC_TEST(MixedCall_0) { Run_WasmMixedCall_N(execution_mode, 0); }
+WASM_EXEC_TEST(MixedCall_1) { Run_WasmMixedCall_N(execution_mode, 1); }
+WASM_EXEC_TEST(MixedCall_2) { Run_WasmMixedCall_N(execution_mode, 2); }
+WASM_EXEC_TEST(MixedCall_3) { Run_WasmMixedCall_N(execution_mode, 3); }
WASM_EXEC_TEST(AddCall) {
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t1(sigs.i_ii(), &module);
BUILD(t1, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
t1.CompileAndAdd();
@@ -2175,9 +2253,9 @@
byte local = r.AllocateLocal(kAstI32);
BUILD(r, B2(WASM_SET_LOCAL(local, WASM_I8(99)),
WASM_I32_ADD(
- WASM_CALL_FUNCTION2(t1.function_index_, WASM_GET_LOCAL(0),
+ 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_CALL_FUNCTION2(t1.function_index(), WASM_GET_LOCAL(1),
WASM_GET_LOCAL(local)))));
CHECK_EQ(198, r.Call(0));
@@ -2186,7 +2264,7 @@
}
WASM_EXEC_TEST(CountDown_expr) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, WASM_LOOP(
3, WASM_IF(WASM_NOT(WASM_GET_LOCAL(0)),
WASM_BREAKV(1, WASM_GET_LOCAL(0))),
@@ -2198,35 +2276,35 @@
}
WASM_EXEC_TEST(ExprBlock2a) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
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));
}
WASM_EXEC_TEST(ExprBlock2b) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
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));
}
WASM_EXEC_TEST(ExprBlock2c) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
}
WASM_EXEC_TEST(ExprBlock2d) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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));
}
WASM_EXEC_TEST(ExprBlock_ManualSwitch) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, WASM_BLOCK(6, WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(1)),
WASM_BRV(1, WASM_I8(11))),
WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(2)),
@@ -2248,7 +2326,7 @@
}
WASM_EXEC_TEST(ExprBlock_ManualSwitch_brif) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r,
WASM_BLOCK(6, WASM_BRV_IF(0, WASM_I8(11),
WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(1))),
@@ -2271,7 +2349,8 @@
}
WASM_EXEC_TEST(nested_ifs) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
+ MachineType::Int32());
BUILD(r, WASM_IF_ELSE(
WASM_GET_LOCAL(0),
@@ -2285,7 +2364,7 @@
}
WASM_EXEC_TEST(ExprBlock_if) {
- WasmRunner<int32_t> r(MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
BUILD(r, B1(WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_BRV(0, WASM_I8(11)),
WASM_BRV(1, WASM_I8(14)))));
@@ -2295,7 +2374,8 @@
}
WASM_EXEC_TEST(ExprBlock_nested_ifs) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
+ MachineType::Int32());
BUILD(r, WASM_BLOCK(
1, WASM_IF_ELSE(
@@ -2312,7 +2392,8 @@
}
WASM_EXEC_TEST(ExprLoop_nested_ifs) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
+ MachineType::Int32());
BUILD(r, WASM_LOOP(
1, WASM_IF_ELSE(
@@ -2330,7 +2411,7 @@
WASM_EXEC_TEST(SimpleCallIndirect) {
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t1(sigs.i_ii(), &module);
BUILD(t1, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2361,7 +2442,7 @@
WASM_EXEC_TEST(MultipleCallIndirect) {
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
WasmFunctionCompiler t1(sigs.i_ii(), &module);
BUILD(t1, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2403,7 +2484,7 @@
WASM_EXEC_TEST(CallIndirect_NoTable) {
TestSignatures sigs;
- TestingModule module;
+ TestingModule module(execution_mode);
// One function.
WasmFunctionCompiler t1(sigs.i_ii(), &module);
@@ -2424,63 +2505,64 @@
}
WASM_EXEC_TEST(F32Floor) {
- WasmRunner<float> r(MachineType::Float32());
+ WasmRunner<float> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_F32_FLOOR(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(floorf(*i), r.Call(*i)); }
}
WASM_EXEC_TEST(F32Ceil) {
- WasmRunner<float> r(MachineType::Float32());
+ WasmRunner<float> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_F32_CEIL(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(ceilf(*i), r.Call(*i)); }
}
WASM_EXEC_TEST(F32Trunc) {
- WasmRunner<float> r(MachineType::Float32());
+ WasmRunner<float> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_F32_TRUNC(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(truncf(*i), r.Call(*i)); }
}
WASM_EXEC_TEST(F32NearestInt) {
- WasmRunner<float> r(MachineType::Float32());
+ WasmRunner<float> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_F32_NEARESTINT(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(nearbyintf(*i), r.Call(*i)); }
}
WASM_EXEC_TEST(F64Floor) {
- WasmRunner<double> r(MachineType::Float64());
+ WasmRunner<double> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_F64_FLOOR(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(floor(*i), r.Call(*i)); }
}
WASM_EXEC_TEST(F64Ceil) {
- WasmRunner<double> r(MachineType::Float64());
+ WasmRunner<double> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_F64_CEIL(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ceil(*i), r.Call(*i)); }
}
WASM_EXEC_TEST(F64Trunc) {
- WasmRunner<double> r(MachineType::Float64());
+ WasmRunner<double> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_F64_TRUNC(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(trunc(*i), r.Call(*i)); }
}
WASM_EXEC_TEST(F64NearestInt) {
- WasmRunner<double> r(MachineType::Float64());
+ WasmRunner<double> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_F64_NEARESTINT(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(nearbyint(*i), r.Call(*i)); }
}
WASM_EXEC_TEST(F32Min) {
- WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
+ WasmRunner<float> r(execution_mode, MachineType::Float32(),
+ MachineType::Float32());
BUILD(r, WASM_F32_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT32_INPUTS(i) {
@@ -2503,7 +2585,8 @@
}
WASM_EXEC_TEST(F64Min) {
- WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
+ WasmRunner<double> r(execution_mode, MachineType::Float64(),
+ MachineType::Float64());
BUILD(r, WASM_F64_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT64_INPUTS(i) {
@@ -2526,7 +2609,8 @@
}
WASM_EXEC_TEST(F32Max) {
- WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
+ WasmRunner<float> r(execution_mode, MachineType::Float32(),
+ MachineType::Float32());
BUILD(r, WASM_F32_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT32_INPUTS(i) {
@@ -2549,7 +2633,8 @@
}
WASM_EXEC_TEST(F64Max) {
- WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
+ WasmRunner<double> r(execution_mode, MachineType::Float64(),
+ MachineType::Float64());
BUILD(r, WASM_F64_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT64_INPUTS(i) {
@@ -2577,13 +2662,13 @@
WASM_EXEC_TEST(F32Min_Snan) {
// Test that the instruction does not return a signalling NaN.
{
- WasmRunner<float> r;
+ WasmRunner<float> r(execution_mode);
BUILD(r,
WASM_F32_MIN(WASM_F32(bit_cast<float>(0xff80f1e2)), WASM_F32(57.67)));
CHECK_EQ(0xffc0f1e2, bit_cast<uint32_t>(r.Call()));
}
{
- WasmRunner<float> r;
+ WasmRunner<float> r(execution_mode);
BUILD(r,
WASM_F32_MIN(WASM_F32(45.73), WASM_F32(bit_cast<float>(0x7f80f1e2))));
CHECK_EQ(0x7fc0f1e2, bit_cast<uint32_t>(r.Call()));
@@ -2593,13 +2678,13 @@
WASM_EXEC_TEST(F32Max_Snan) {
// Test that the instruction does not return a signalling NaN.
{
- WasmRunner<float> r;
+ WasmRunner<float> r(execution_mode);
BUILD(r,
WASM_F32_MAX(WASM_F32(bit_cast<float>(0xff80f1e2)), WASM_F32(57.67)));
CHECK_EQ(0xffc0f1e2, bit_cast<uint32_t>(r.Call()));
}
{
- WasmRunner<float> r;
+ WasmRunner<float> r(execution_mode);
BUILD(r,
WASM_F32_MAX(WASM_F32(45.73), WASM_F32(bit_cast<float>(0x7f80f1e2))));
CHECK_EQ(0x7fc0f1e2, bit_cast<uint32_t>(r.Call()));
@@ -2609,13 +2694,13 @@
WASM_EXEC_TEST(F64Min_Snan) {
// Test that the instruction does not return a signalling NaN.
{
- WasmRunner<double> r;
+ WasmRunner<double> r(execution_mode);
BUILD(r, WASM_F64_MIN(WASM_F64(bit_cast<double>(0xfff000000000f1e2)),
WASM_F64(57.67)));
CHECK_EQ(0xfff800000000f1e2, bit_cast<uint64_t>(r.Call()));
}
{
- WasmRunner<double> r;
+ WasmRunner<double> r(execution_mode);
BUILD(r, WASM_F64_MIN(WASM_F64(45.73),
WASM_F64(bit_cast<double>(0x7ff000000000f1e2))));
CHECK_EQ(0x7ff800000000f1e2, bit_cast<uint64_t>(r.Call()));
@@ -2625,13 +2710,13 @@
WASM_EXEC_TEST(F64Max_Snan) {
// Test that the instruction does not return a signalling NaN.
{
- WasmRunner<double> r;
+ WasmRunner<double> r(execution_mode);
BUILD(r, WASM_F64_MAX(WASM_F64(bit_cast<double>(0xfff000000000f1e2)),
WASM_F64(57.67)));
CHECK_EQ(0xfff800000000f1e2, bit_cast<uint64_t>(r.Call()));
}
{
- WasmRunner<double> r;
+ WasmRunner<double> r(execution_mode);
BUILD(r, WASM_F64_MAX(WASM_F64(45.73),
WASM_F64(bit_cast<double>(0x7ff000000000f1e2))));
CHECK_EQ(0x7ff800000000f1e2, bit_cast<uint64_t>(r.Call()));
@@ -2641,7 +2726,7 @@
#endif
WASM_EXEC_TEST(I32SConvertF32) {
- WasmRunner<int32_t> r(MachineType::Float32());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_I32_SCONVERT_F32(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -2655,7 +2740,7 @@
}
WASM_EXEC_TEST(I32SConvertF64) {
- WasmRunner<int32_t> r(MachineType::Float64());
+ WasmRunner<int32_t> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_I32_SCONVERT_F64(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -2669,7 +2754,7 @@
}
WASM_EXEC_TEST(I32UConvertF32) {
- WasmRunner<uint32_t> r(MachineType::Float32());
+ WasmRunner<uint32_t> r(execution_mode, MachineType::Float32());
BUILD(r, WASM_I32_UCONVERT_F32(WASM_GET_LOCAL(0)));
FOR_FLOAT32_INPUTS(i) {
@@ -2682,7 +2767,7 @@
}
WASM_EXEC_TEST(I32UConvertF64) {
- WasmRunner<uint32_t> r(MachineType::Float64());
+ WasmRunner<uint32_t> r(execution_mode, MachineType::Float64());
BUILD(r, WASM_I32_UCONVERT_F64(WASM_GET_LOCAL(0)));
FOR_FLOAT64_INPUTS(i) {
@@ -2695,7 +2780,8 @@
}
WASM_EXEC_TEST(F64CopySign) {
- WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
+ WasmRunner<double> r(execution_mode, MachineType::Float64(),
+ MachineType::Float64());
BUILD(r, WASM_F64_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT64_INPUTS(i) {
@@ -2704,7 +2790,8 @@
}
WASM_EXEC_TEST(F32CopySign) {
- WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
+ WasmRunner<float> r(execution_mode, MachineType::Float32(),
+ MachineType::Float32());
BUILD(r, WASM_F32_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
FOR_FLOAT32_INPUTS(i) {
@@ -2712,15 +2799,15 @@
}
}
-void CompileCallIndirectMany(LocalType param) {
+static void CompileCallIndirectMany(LocalType param) {
// Make sure we don't run out of registers when compiling indirect calls
// with many many parameters.
TestSignatures sigs;
- for (byte num_params = 0; num_params < 40; num_params++) {
+ for (byte num_params = 0; num_params < 40; ++num_params) {
v8::base::AccountingAllocator allocator;
Zone zone(&allocator);
HandleScope scope(CcTest::InitIsolateOnce());
- TestingModule module;
+ TestingModule module(kExecuteCompiled);
FunctionSig* sig = sigs.many(&zone, kAstStmt, param, num_params);
module.AddSignature(sig);
@@ -2731,7 +2818,7 @@
std::vector<byte> code;
ADD_CODE(code, kExprI8Const, 0);
- for (byte p = 0; p < num_params; p++) {
+ for (byte p = 0; p < num_params; ++p) {
ADD_CODE(code, kExprGetLocal, p);
}
ADD_CODE(code, kExprCallIndirect, static_cast<byte>(num_params), 1);
@@ -2743,16 +2830,13 @@
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); }
WASM_EXEC_TEST(Int32RemS_dead) {
- WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
+ WasmRunner<int32_t> r(execution_mode, 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();
CHECK_EQ(0, r.Call(133, 100));
diff --git a/test/cctest/wasm/test-wasm-function-name-table.cc b/test/cctest/wasm/test-wasm-function-name-table.cc
index 2f1e251..1ae78dc 100644
--- a/test/cctest/wasm/test-wasm-function-name-table.cc
+++ b/test/cctest/wasm/test-wasm-function-name-table.cc
@@ -30,17 +30,20 @@
WasmModule module;
std::vector<char> all_names;
+ // No name should have offset 0, because that encodes unnamed functions.
+ // In real wasm binary, offset 0 is impossible anyway.
+ all_names.push_back('\0');
uint32_t func_index = 0;
for (Vector<const char> name : names) {
- size_t name_offset = all_names.size();
+ size_t name_offset = name.start() ? all_names.size() : 0;
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});
+ module.functions.push_back({nullptr, 0, 0,
+ static_cast<uint32_t>(name_offset),
+ static_cast<uint32_t>(name.length()), 0, 0});
++func_index;
}
@@ -53,19 +56,21 @@
func_index = 0;
for (Vector<const char> name : names) {
- Handle<Object> string_obj = GetWasmFunctionNameFromTable(
+ MaybeHandle<String> string = 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));
+ if (name.start()) {
+ CHECK(string.ToHandleChecked()->IsUtf8EqualTo(name));
+ } else {
+ CHECK(string.is_null());
+ }
++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));
+ for (const char *name : names)
+ names_vec.push_back(name ? CStrVector(name) : Vector<const char>());
testFunctionNameTable(Vector<Vector<const char>>(
names_vec.data(), static_cast<int>(names_vec.size())));
}
@@ -108,3 +113,8 @@
const char *names[] = {"↱fun↰", "↺", "alpha:α beta:β"};
testFunctionNameTable(ArrayVector(names));
}
+
+TEST(UnnamedVsEmptyNames) {
+ const char *names[] = {"", nullptr, nullptr, ""};
+ testFunctionNameTable(ArrayVector(names));
+}
diff --git a/test/cctest/wasm/test-wasm-stack.cc b/test/cctest/wasm/test-wasm-stack.cc
index b6cd674..f2a8481 100644
--- a/test/cctest/wasm/test-wasm-stack.cc
+++ b/test/cctest/wasm/test-wasm-stack.cc
@@ -51,10 +51,10 @@
};
template <int N>
-void CheckExceptionInfos(Isolate* isolate, Handle<Object> exc,
+void CheckExceptionInfos(Handle<Object> exc,
const ExceptionInfo (&excInfos)[N]) {
// Check that it's indeed an Error object.
- CHECK(Object::IsErrorObject(isolate, exc));
+ CHECK(exc->IsJSError());
// Extract stack frame from the exception.
Local<v8::Value> localExc = Utils::ToLocal(exc);
@@ -110,16 +110,15 @@
Execution::TryCall(isolate, js_trampoline, global, 1, args, &maybe_exc);
CHECK(returnObjMaybe.is_null());
- // Line number is 1-based, with 0 == kNoLineNumberInfo.
+ // The column is 1-based, so add 1 to the actual byte offset.
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} // -
+ {"a", 3, 8}, // -
+ {"js", 4, 2}, // -
+ {"<WASM UNNAMED>", static_cast<int>(wasm_index), 3}, // -
+ {"<WASM UNNAMED>", static_cast<int>(wasm_index_2), 2}, // -
+ {"callFn", 1, 24} // -
};
- CheckExceptionInfos(isolate, maybe_exc.ToHandleChecked(),
- expected_exceptions);
+ CheckExceptionInfos(maybe_exc.ToHandleChecked(), expected_exceptions);
}
// Trigger a trap in WASM, stack should be JS -> WASM -> WASM.
@@ -155,12 +154,11 @@
Execution::TryCall(isolate, js_trampoline, global, 1, args, &maybe_exc);
CHECK(maybe_return_obj.is_null());
- // Line number is 1-based, with 0 == kNoLineNumberInfo.
+ // The column is 1-based, so add 1 to the actual byte offset.
ExceptionInfo expected_exceptions[] = {
- {"<WASM>", static_cast<int>(wasm_index), 1}, // -
- {"<WASM>", static_cast<int>(wasm_index_2), 1}, // -
- {"callFn", 1, 24} //-
+ {"<WASM UNNAMED>", static_cast<int>(wasm_index), 2}, // -
+ {"<WASM UNNAMED>", static_cast<int>(wasm_index_2), 2}, // -
+ {"callFn", 1, 24} //-
};
- CheckExceptionInfos(isolate, maybe_exc.ToHandleChecked(),
- expected_exceptions);
+ CheckExceptionInfos(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
index 13f2929..30f5d48 100644
--- a/test/cctest/wasm/test-wasm-trap-position.cc
+++ b/test/cctest/wasm/test-wasm-trap-position.cc
@@ -38,10 +38,10 @@
};
template <int N>
-void CheckExceptionInfos(Isolate* isolate, Handle<Object> exc,
+void CheckExceptionInfos(Handle<Object> exc,
const ExceptionInfo (&excInfos)[N]) {
// Check that it's indeed an Error object.
- CHECK(Object::IsErrorObject(isolate, exc));
+ CHECK(exc->IsJSError());
// Extract stack frame from the exception.
Local<v8::Value> localExc = Utils::ToLocal(exc);
@@ -88,12 +88,12 @@
Execution::TryCall(isolate, js_trampoline, global, 1, args, &maybe_exc);
CHECK(returnObjMaybe.is_null());
+ // The column is 1-based, so add 1 to the actual byte offset.
ExceptionInfo expected_exceptions[] = {
- {"<WASM>", static_cast<int>(wasm_index), 1}, // --
- {"callFn", 1, 24} // --
+ {"<WASM UNNAMED>", static_cast<int>(wasm_index), 2}, // --
+ {"callFn", 1, 24} // --
};
- CheckExceptionInfos(isolate, maybe_exc.ToHandleChecked(),
- expected_exceptions);
+ CheckExceptionInfos(maybe_exc.ToHandleChecked(), expected_exceptions);
}
// Trigger a trap for loading from out-of-bounds.
@@ -129,12 +129,11 @@
Execution::TryCall(isolate, js_trampoline, global, 1, args, &maybe_exc);
CHECK(returnObjMaybe.is_null());
- // Line number is 1-based, with 0 == kNoLineNumberInfo.
+ // The column is 1-based, so add 1 to the actual byte offset.
ExceptionInfo expected_exceptions[] = {
- {"<WASM>", static_cast<int>(wasm_index), 6}, // --
- {"<WASM>", static_cast<int>(wasm_index_2), 2}, // --
- {"callFn", 1, 24} // --
+ {"<WASM UNNAMED>", static_cast<int>(wasm_index), 7}, // --
+ {"<WASM UNNAMED>", static_cast<int>(wasm_index_2), 3}, // --
+ {"callFn", 1, 24} // --
};
- CheckExceptionInfos(isolate, maybe_exc.ToHandleChecked(),
- expected_exceptions);
+ CheckExceptionInfos(maybe_exc.ToHandleChecked(), expected_exceptions);
}
diff --git a/test/cctest/wasm/wasm-run-utils.h b/test/cctest/wasm/wasm-run-utils.h
index a92c9ff..1f758bb 100644
--- a/test/cctest/wasm/wasm-run-utils.h
+++ b/test/cctest/wasm/wasm-run-utils.h
@@ -9,6 +9,7 @@
#include <stdlib.h>
#include <string.h>
+#include "src/base/accounting-allocator.h"
#include "src/base/utils/random-number-generator.h"
#include "src/compiler/graph-visualizer.h"
@@ -20,6 +21,7 @@
#include "src/compiler/zone-pool.h"
#include "src/wasm/ast-decoder.h"
+#include "src/wasm/wasm-interpreter.h"
#include "src/wasm/wasm-js.h"
#include "src/wasm/wasm-macro-gen.h"
#include "src/wasm/wasm-module.h"
@@ -31,15 +33,10 @@
#include "test/cctest/compiler/call-tester.h"
#include "test/cctest/compiler/graph-builder-tester.h"
-// TODO(titzer): pull WASM_64 up to a common header.
-#if !V8_TARGET_ARCH_32_BIT || V8_TARGET_ARCH_X64
-#define WASM_64 1
-#else
-#define WASM_64 0
-#endif
-
static const uint32_t kMaxFunctions = 10;
+enum WasmExecutionMode { kExecuteInterpreted, kExecuteCompiled };
+
// TODO(titzer): check traps more robustly in tests.
// Currently, in tests, we just return 0xdeadbeef from the function in which
// the trap occurs if the runtime context is not available to throw a JavaScript
@@ -72,16 +69,21 @@
// {WasmModuleInstance}.
class TestingModule : public ModuleEnv {
public:
- TestingModule() : instance_(&module_), global_offset(0) {
- module_.shared_isolate = CcTest::InitIsolateOnce();
+ explicit TestingModule(WasmExecutionMode mode = kExecuteCompiled)
+ : execution_mode_(mode),
+ instance_(&module_),
+ isolate_(CcTest::InitIsolateOnce()),
+ global_offset(0),
+ interpreter_(mode == kExecuteInterpreted
+ ? new WasmInterpreter(&instance_, &allocator_)
+ : nullptr) {
module = &module_;
instance = &instance_;
instance->module = &module_;
instance->globals_start = global_data;
- instance->globals_size = kMaxGlobalsSize;
+ module_.globals_size = kMaxGlobalsSize;
instance->mem_start = nullptr;
instance->mem_size = 0;
- linker = nullptr;
origin = kWasmOrigin;
memset(global_data, 0, sizeof(global_data));
}
@@ -90,9 +92,10 @@
if (instance->mem_start) {
free(instance->mem_start);
}
+ if (interpreter_) delete interpreter_;
}
- byte* AddMemory(size_t size) {
+ byte* AddMemory(uint32_t size) {
CHECK_NULL(instance->mem_start);
CHECK_EQ(0, instance->mem_size);
instance->mem_start = reinterpret_cast<byte*>(malloc(size));
@@ -103,19 +106,19 @@
}
template <typename T>
- T* AddMemoryElems(size_t count) {
+ T* AddMemoryElems(uint32_t count) {
AddMemory(count * sizeof(T));
return raw_mem_start<T>();
}
template <typename T>
T* AddGlobal(MachineType mem_type) {
- WasmGlobal* global = AddGlobal(mem_type);
+ const WasmGlobal* global = AddGlobal(mem_type);
return reinterpret_cast<T*>(instance->globals_start + global->offset);
}
byte AddSignature(FunctionSig* sig) {
- module->signatures.push_back(sig);
+ module_.signatures.push_back(sig);
size_t size = module->signatures.size();
CHECK(size < 127);
return static_cast<byte>(size - 1);
@@ -165,11 +168,16 @@
if (module->functions.size() == 0) {
// TODO(titzer): Reserving space here to avoid the underlying WasmFunction
// structs from moving.
- module->functions.reserve(kMaxFunctions);
+ 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, false});
+ module_.functions.push_back({sig, index, 0, 0, 0, 0, 0});
instance->function_code.push_back(code);
+ if (interpreter_) {
+ const WasmFunction* function = &module->functions.back();
+ int interpreter_index = interpreter_->AddFunctionForTesting(function);
+ CHECK_EQ(index, static_cast<uint32_t>(interpreter_index));
+ }
DCHECK_LT(index, kMaxFunctions); // limited for testing.
return index;
}
@@ -178,23 +186,21 @@
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,
+ Handle<Code> code = CompileWasmToJSWrapper(isolate_, 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<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,
+ WasmJs::InstallWasmFunctionMap(isolate_, isolate_->native_context());
+ return compiler::CompileJSToWasmWrapper(isolate_, this, name, code,
module_object, index);
}
@@ -203,13 +209,12 @@
}
void AddIndirectFunctionTable(int* functions, int table_size) {
- Isolate* isolate = module->shared_isolate;
Handle<FixedArray> fixed =
- isolate->factory()->NewFixedArray(2 * table_size);
+ isolate_->factory()->NewFixedArray(2 * table_size);
instance->function_table = fixed;
DCHECK_EQ(0u, module->function_table.size());
for (int i = 0; i < table_size; i++) {
- module->function_table.push_back(functions[i]);
+ module_.function_table.push_back(functions[i]);
}
}
@@ -218,23 +223,31 @@
int table_size = static_cast<int>(module->function_table.size());
for (int i = 0; i < table_size; i++) {
int function_index = module->function_table[i];
- WasmFunction* function = &module->functions[function_index];
+ const WasmFunction* function = &module->functions[function_index];
instance->function_table->set(i, Smi::FromInt(function->sig_index));
instance->function_table->set(i + table_size,
*instance->function_code[function_index]);
}
}
+ WasmFunction* GetFunctionAt(int index) { return &module_.functions[index]; }
+
+ WasmInterpreter* interpreter() { return interpreter_; }
+ WasmExecutionMode execution_mode() { return execution_mode_; }
private:
+ WasmExecutionMode execution_mode_;
WasmModule module_;
WasmModuleInstance instance_;
+ Isolate* isolate_;
+ v8::base::AccountingAllocator allocator_;
uint32_t global_offset;
V8_ALIGNED(8) byte global_data[kMaxGlobalsSize]; // preallocated global data.
+ WasmInterpreter* interpreter_;
- WasmGlobal* AddGlobal(MachineType mem_type) {
+ const WasmGlobal* AddGlobal(MachineType mem_type) {
byte size = WasmOpcodes::MemSize(mem_type);
global_offset = (global_offset + size - 1) & ~(size - 1); // align
- module->globals.push_back({0, 0, mem_type, global_offset, false});
+ module_.globals.push_back({0, 0, mem_type, global_offset, false});
global_offset += size;
// limit number of globals.
CHECK_LT(global_offset, kMaxGlobalsSize);
@@ -408,14 +421,41 @@
// A helper for compiling WASM functions for testing. This class can create a
// standalone function if {module} is NULL or a function within a
// {TestingModule}. It contains the internal state for compilation (i.e.
-// TurboFan graph) and, later, interpretation.
+// TurboFan graph) and interpretation (by adding to the interpreter manually).
class WasmFunctionCompiler : public HandleAndZoneScope,
private GraphAndBuilders {
public:
explicit WasmFunctionCompiler(
+ FunctionSig* sig, WasmExecutionMode mode,
+ Vector<const char> debug_name = ArrayVector("<WASM UNNAMED>"))
+ : GraphAndBuilders(main_zone()),
+ execution_mode_(mode),
+ jsgraph(this->isolate(), this->graph(), this->common(), nullptr,
+ nullptr, this->machine()),
+ sig(sig),
+ descriptor_(nullptr),
+ testing_module_(nullptr),
+ debug_name_(debug_name),
+ local_decls(main_zone(), sig),
+ source_position_table_(this->graph()),
+ interpreter_(nullptr) {
+ // Create our own function.
+ function_ = new WasmFunction();
+ function_->sig = sig;
+ function_->func_index = 0;
+ function_->sig_index = 0;
+ if (mode == kExecuteInterpreted) {
+ interpreter_ = new WasmInterpreter(nullptr, zone()->allocator());
+ int index = interpreter_->AddFunctionForTesting(function_);
+ CHECK_EQ(0, index);
+ }
+ }
+
+ explicit WasmFunctionCompiler(
FunctionSig* sig, TestingModule* module,
Vector<const char> debug_name = ArrayVector("<WASM UNNAMED>"))
: GraphAndBuilders(main_zone()),
+ execution_mode_(module->execution_mode()),
jsgraph(this->isolate(), this->graph(), this->common(), nullptr,
nullptr, this->machine()),
sig(sig),
@@ -423,23 +463,20 @@
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;
- function_index_ = module->AddFunction(sig, Handle<Code>::null());
- } else {
- // Create our own function.
- function_ = new WasmFunction();
- function_->sig = sig;
- function_index_ = 0;
- }
+ source_position_table_(this->graph()),
+ interpreter_(module->interpreter()) {
+ // Get a new function from the testing module.
+ int index = module->AddFunction(sig, Handle<Code>::null());
+ function_ = testing_module_->GetFunctionAt(index);
}
~WasmFunctionCompiler() {
- if (function_) delete function_;
+ if (testing_module_) return; // testing module owns the below things.
+ delete function_;
+ if (interpreter_) delete interpreter_;
}
+ WasmExecutionMode execution_mode_;
JSGraph jsgraph;
FunctionSig* sig;
// The call descriptor is initialized when the function is compiled.
@@ -447,9 +484,9 @@
TestingModule* testing_module_;
Vector<const char> debug_name_;
WasmFunction* function_;
- int function_index_;
LocalDeclEncoder local_decls;
SourcePositionTable source_position_table_;
+ WasmInterpreter* interpreter_;
Isolate* isolate() { return main_isolate(); }
Graph* graph() const { return main_graph_; }
@@ -462,13 +499,17 @@
}
}
CallDescriptor* descriptor() { return descriptor_; }
+ uint32_t function_index() { return function_->func_index; }
void Build(const byte* start, const byte* end) {
// Build the TurboFan graph.
- local_decls.Prepend(&start, &end);
+ local_decls.Prepend(main_zone(), &start, &end);
TestBuildingGraph(main_zone(), &jsgraph, testing_module_, sig,
&source_position_table_, start, end);
- delete[] start;
+ if (interpreter_) {
+ // Add the code to the interpreter.
+ CHECK(interpreter_->SetFunctionCodeForTesting(function_, start, end));
+ }
}
byte AllocateLocal(LocalType type) {
@@ -494,13 +535,13 @@
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.
+ // 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(1, Smi::FromInt(static_cast<int>(function_index())));
deopt_data->set_length(2);
code->set_deoptimization_data(*deopt_data);
@@ -516,15 +557,10 @@
uint32_t CompileAndAdd(uint16_t sig_index = 0) {
CHECK(testing_module_);
- function()->sig_index = sig_index;
+ function_->sig_index = sig_index;
Handle<Code> code = Compile();
- testing_module_->SetFunctionCode(function_index_, code);
- return static_cast<uint32_t>(function_index_);
- }
-
- WasmFunction* function() {
- if (function_) return function_;
- return &testing_module_->module->functions[function_index_];
+ testing_module_->SetFunctionCode(function_index(), code);
+ return function_index();
}
// Set the context, such that e.g. runtime functions can be called.
@@ -543,7 +579,8 @@
template <typename ReturnType>
class WasmRunner {
public:
- WasmRunner(MachineType p0 = MachineType::None(),
+ WasmRunner(WasmExecutionMode execution_mode,
+ MachineType p0 = MachineType::None(),
MachineType p1 = MachineType::None(),
MachineType p2 = MachineType::None(),
MachineType p3 = MachineType::None())
@@ -551,7 +588,7 @@
compiled_(false),
signature_(MachineTypeForC<ReturnType>() == MachineType::None() ? 0 : 1,
GetParameterCount(p0, p1, p2, p3), storage_),
- compiler_(&signature_, nullptr) {
+ compiler_(&signature_, execution_mode) {
InitSigStorage(p0, p1, p2, p3);
}
@@ -594,51 +631,102 @@
void Build(const byte* start, const byte* end) {
CHECK(!compiled_);
compiled_ = true;
-
- // Build the TF graph within the compiler.
compiler_.Build(start, end);
- // Generate code.
- Handle<Code> code = compiler_.Compile();
- if (compiler_.testing_module_) {
- // Update the table of function code in the module.
- compiler_.testing_module_->SetFunctionCode(compiler_.function_index_,
- code);
+ if (!interpret()) {
+ // Compile machine code and install it into the module.
+ Handle<Code> code = compiler_.Compile();
+
+ if (compiler_.testing_module_) {
+ // Update the table of function code in the module.
+ compiler_.testing_module_->SetFunctionCode(
+ compiler_.function_->func_index, code);
+ }
+
+ wrapper_.SetInnerCode(code);
}
-
- wrapper_.SetInnerCode(code);
}
- ReturnType Call() { return Call(0, 0, 0, 0); }
+ ReturnType Call() {
+ if (interpret()) {
+ return CallInterpreter(Vector<WasmVal>(nullptr, 0));
+ } else {
+ return Call(0, 0, 0, 0);
+ }
+ }
template <typename P0>
ReturnType Call(P0 p0) {
- return Call(p0, 0, 0, 0);
+ if (interpret()) {
+ WasmVal args[] = {WasmVal(p0)};
+ return CallInterpreter(ArrayVector(args));
+ } else {
+ return Call(p0, 0, 0, 0);
+ }
}
template <typename P0, typename P1>
ReturnType Call(P0 p0, P1 p1) {
- return Call(p0, p1, 0, 0);
+ if (interpret()) {
+ WasmVal args[] = {WasmVal(p0), WasmVal(p1)};
+ return CallInterpreter(ArrayVector(args));
+ } else {
+ return Call(p0, p1, 0, 0);
+ }
}
template <typename P0, typename P1, typename P2>
ReturnType Call(P0 p0, P1 p1, P2 p2) {
- return Call(p0, p1, p2, 0);
+ if (interpret()) {
+ WasmVal args[] = {WasmVal(p0), WasmVal(p1), WasmVal(p2)};
+ return CallInterpreter(ArrayVector(args));
+ } else {
+ return Call(p0, p1, p2, 0);
+ }
}
template <typename P0, typename P1, typename P2, typename P3>
ReturnType Call(P0 p0, P1 p1, P2 p2, P3 p3) {
- CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(),
- wrapper_.GetWrapperCode(), wrapper_.signature());
- ReturnType return_value;
- int32_t result = runner.Call<void*, void*, void*, void*, void*>(
- &p0, &p1, &p2, &p3, &return_value);
- CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
- return return_value;
+ if (interpret()) {
+ WasmVal args[] = {WasmVal(p0), WasmVal(p1), WasmVal(p2), WasmVal(p3)};
+ return CallInterpreter(ArrayVector(args));
+ } else {
+ CodeRunner<int32_t> runner(CcTest::InitIsolateOnce(),
+ wrapper_.GetWrapperCode(),
+ wrapper_.signature());
+ ReturnType return_value;
+ int32_t result = runner.Call<void*, void*, void*, void*, void*>(
+ &p0, &p1, &p2, &p3, &return_value);
+ CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
+ return return_value;
+ }
+ }
+
+ ReturnType CallInterpreter(Vector<WasmVal> args) {
+ CHECK_EQ(args.length(),
+ static_cast<int>(compiler_.function_->sig->parameter_count()));
+ WasmInterpreter::Thread* thread = interpreter()->GetThread(0);
+ thread->Reset();
+ thread->PushFrame(compiler_.function_, args.start());
+ if (thread->Run() == WasmInterpreter::FINISHED) {
+ WasmVal val = thread->GetReturnValue();
+ return val.to<ReturnType>();
+ } else if (thread->state() == WasmInterpreter::TRAPPED) {
+ // TODO(titzer): return the correct trap code
+ int64_t result = 0xdeadbeefdeadbeef;
+ return static_cast<ReturnType>(result);
+ } else {
+ // TODO(titzer): falling off end
+ ReturnType val = 0;
+ return val;
+ }
}
byte AllocateLocal(LocalType type) { return compiler_.AllocateLocal(type); }
+ WasmFunction* function() { return compiler_.function_; }
+ WasmInterpreter* interpreter() { return compiler_.interpreter_; }
+
protected:
v8::base::AccountingAllocator allocator_;
Zone zone;
@@ -648,6 +736,8 @@
WasmFunctionCompiler compiler_;
WasmFunctionWrapper<ReturnType> wrapper_;
+ bool interpret() { return compiler_.execution_mode_ == kExecuteInterpreted; }
+
static size_t GetParameterCount(MachineType p0, MachineType p1,
MachineType p2, MachineType p3) {
if (p0 == MachineType::None()) return 0;
@@ -662,10 +752,11 @@
// 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()
+#define WASM_EXEC_TEST(name) \
+ void RunWasm_##name(WasmExecutionMode execution_mode); \
+ TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); } \
+ TEST(RunWasmInterpreted_##name) { RunWasm_##name(kExecuteInterpreted); } \
+ void RunWasm_##name(WasmExecutionMode execution_mode)
} // namespace
diff --git a/test/fuzzer/fuzzer-support.cc b/test/fuzzer/fuzzer-support.cc
index 5df0bd8..ea9fb09 100644
--- a/test/fuzzer/fuzzer-support.cc
+++ b/test/fuzzer/fuzzer-support.cc
@@ -40,7 +40,7 @@
FuzzerSupport::FuzzerSupport(int* argc, char*** argv) {
v8::internal::FLAG_expose_gc = true;
v8::V8::SetFlagsFromCommandLine(argc, *argv, true);
- v8::V8::InitializeICU();
+ v8::V8::InitializeICUDefaultLocation((*argv)[0]);
v8::V8::InitializeExternalStartupData((*argv)[0]);
platform_ = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(platform_);
diff --git a/test/fuzzer/fuzzer.gyp b/test/fuzzer/fuzzer.gyp
index b125ec2..c7c4cb4 100644
--- a/test/fuzzer/fuzzer.gyp
+++ b/test/fuzzer/fuzzer.gyp
@@ -9,7 +9,7 @@
'includes': ['../../gypfiles/toolchain.gypi', '../../gypfiles/features.gypi'],
'targets': [
{
- 'target_name': 'json_fuzzer',
+ 'target_name': 'v8_simple_json_fuzzer',
'type': 'executable',
'dependencies': [
'json_fuzzer_lib',
@@ -35,7 +35,7 @@
],
},
{
- 'target_name': 'parser_fuzzer',
+ 'target_name': 'v8_simple_parser_fuzzer',
'type': 'executable',
'dependencies': [
'parser_fuzzer_lib',
@@ -61,7 +61,7 @@
],
},
{
- 'target_name': 'regexp_fuzzer',
+ 'target_name': 'v8_simple_regexp_fuzzer',
'type': 'executable',
'dependencies': [
'regexp_fuzzer_lib',
@@ -87,7 +87,7 @@
],
},
{
- 'target_name': 'wasm_fuzzer',
+ 'target_name': 'v8_simple_wasm_fuzzer',
'type': 'executable',
'dependencies': [
'wasm_fuzzer_lib',
@@ -113,7 +113,7 @@
],
},
{
- 'target_name': 'wasm_asmjs_fuzzer',
+ 'target_name': 'v8_simple_wasm_asmjs_fuzzer',
'type': 'executable',
'dependencies': [
'wasm_asmjs_fuzzer_lib',
@@ -169,9 +169,11 @@
'target_name': 'fuzzer_run',
'type': 'none',
'dependencies': [
- 'json_fuzzer',
- 'parser_fuzzer',
- 'regexp_fuzzer',
+ 'v8_simple_json_fuzzer',
+ 'v8_simple_parser_fuzzer',
+ 'v8_simple_regexp_fuzzer',
+ 'v8_simple_wasm_fuzzer',
+ 'v8_simple_wasm_asmjs_fuzzer',
],
'includes': [
'../../gypfiles/isolate.gypi',
diff --git a/test/fuzzer/fuzzer.isolate b/test/fuzzer/fuzzer.isolate
index 4e98edd..2611c72 100644
--- a/test/fuzzer/fuzzer.isolate
+++ b/test/fuzzer/fuzzer.isolate
@@ -5,11 +5,11 @@
{
'variables': {
'files': [
- '<(PRODUCT_DIR)/json_fuzzer<(EXECUTABLE_SUFFIX)',
- '<(PRODUCT_DIR)/parser_fuzzer<(EXECUTABLE_SUFFIX)',
- '<(PRODUCT_DIR)/regexp_fuzzer<(EXECUTABLE_SUFFIX)',
- '<(PRODUCT_DIR)/wasm_fuzzer<(EXECUTABLE_SUFFIX)',
- '<(PRODUCT_DIR)/wasm_asmjs_fuzzer<(EXECUTABLE_SUFFIX)',
+ '<(PRODUCT_DIR)/v8_simple_json_fuzzer<(EXECUTABLE_SUFFIX)',
+ '<(PRODUCT_DIR)/v8_simple_parser_fuzzer<(EXECUTABLE_SUFFIX)',
+ '<(PRODUCT_DIR)/v8_simple_regexp_fuzzer<(EXECUTABLE_SUFFIX)',
+ '<(PRODUCT_DIR)/v8_simple_wasm_fuzzer<(EXECUTABLE_SUFFIX)',
+ '<(PRODUCT_DIR)/v8_simple_wasm_asmjs_fuzzer<(EXECUTABLE_SUFFIX)',
'./fuzzer.status',
'./testcfg.py',
'./json/',
diff --git a/test/fuzzer/regexp.cc b/test/fuzzer/regexp.cc
index 64c03ae..40e3470 100644
--- a/test/fuzzer/regexp.cc
+++ b/test/fuzzer/regexp.cc
@@ -30,7 +30,6 @@
v8::Context::Scope context_scope(support->GetContext());
v8::TryCatch try_catch(isolate);
- i::FLAG_harmony_unicode_regexps = true;
i::FLAG_harmony_regexp_lookbehind = true;
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
diff --git a/test/fuzzer/testcfg.py b/test/fuzzer/testcfg.py
index 35a5abb..85a38ed 100644
--- a/test/fuzzer/testcfg.py
+++ b/test/fuzzer/testcfg.py
@@ -26,7 +26,7 @@
def ListTests(self, context):
tests = []
for subtest in FuzzerTestSuite.SUB_TESTS:
- shell = '%s_fuzzer' % subtest
+ shell = 'v8_simple_%s_fuzzer' % subtest
for fname in os.listdir(os.path.join(self.root, subtest)):
if not os.path.isfile(os.path.join(self.root, subtest, fname)):
continue
diff --git a/test/fuzzer/wasm-asmjs.cc b/test/fuzzer/wasm-asmjs.cc
index 3f7477b..cb8b86b 100644
--- a/test/fuzzer/wasm-asmjs.cc
+++ b/test/fuzzer/wasm-asmjs.cc
@@ -33,7 +33,7 @@
v8::TryCatch try_catch(isolate);
v8::internal::WasmJs::InstallWasmFunctionMap(i_isolate,
i_isolate->native_context());
- v8::internal::wasm::CompileAndRunWasmModule(i_isolate, data, data + size,
- true);
+ v8::internal::wasm::testing::CompileAndRunWasmModule(i_isolate, data,
+ data + size, true);
return 0;
}
diff --git a/test/fuzzer/wasm.cc b/test/fuzzer/wasm.cc
index 8750cbf..27259c6 100644
--- a/test/fuzzer/wasm.cc
+++ b/test/fuzzer/wasm.cc
@@ -33,7 +33,7 @@
v8::TryCatch try_catch(isolate);
v8::internal::WasmJs::InstallWasmFunctionMap(i_isolate,
i_isolate->native_context());
- v8::internal::wasm::CompileAndRunWasmModule(i_isolate, data, data + size,
- false);
+ v8::internal::wasm::testing::CompileAndRunWasmModule(i_isolate, data,
+ data + size, false);
return 0;
}
diff --git a/test/intl/date-format/parse-MMMdy.js b/test/intl/date-format/parse-MMMdy.js
index f713b36..f8291f4 100644
--- a/test/intl/date-format/parse-MMMdy.js
+++ b/test/intl/date-format/parse-MMMdy.js
@@ -43,11 +43,17 @@
assertEquals(1, date.getUTCMonth());
assertEquals(4, date.getUTCDate());
-// Missing , in the pattern.
-assertEquals(undefined, dtf.v8Parse('Feb 4 1974'));
+// Can deal with a missing ','.
+date = dtf.v8Parse('Feb 4 1974');
+assertEquals(1974, date.getUTCFullYear());
+assertEquals(1, date.getUTCMonth());
+assertEquals(4, date.getUTCDate());
// Extra "th" after 4 in the pattern.
assertEquals(undefined, dtf.v8Parse('Feb 4th, 1974'));
-// Wrong pattern.
-assertEquals(undefined, dtf.v8Parse('2/4/1974'));
+// TODO(jshin): Make sure if this is what's supposed to be.
+date = dtf.v8Parse('2/4/1974');
+assertEquals(1974, date.getUTCFullYear());
+assertEquals(1, date.getUTCMonth());
+assertEquals(4, date.getUTCDate());
diff --git a/test/intl/date-format/parse-mdyhms.js b/test/intl/date-format/parse-mdyhms.js
index 73efb62..766f719 100644
--- a/test/intl/date-format/parse-mdyhms.js
+++ b/test/intl/date-format/parse-mdyhms.js
@@ -26,6 +26,8 @@
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Testing v8Parse method for date and time pattern.
+//
+// Flags: --intl-extra
var dtf = new Intl.DateTimeFormat(['en'],
{year: 'numeric', month: 'numeric',
@@ -34,7 +36,7 @@
timeZone: 'UTC'});
// Make sure we have pattern we expect (may change in the future).
-assertEquals('M/d/y h:mm:ss a', dtf.resolved.pattern);
+assertEquals('M/d/y, h:mm:ss a', dtf.resolved.pattern);
var date = dtf.v8Parse('2/4/74 12:30:42 pm');
assertEquals(1974, date.getUTCFullYear());
@@ -44,14 +46,20 @@
assertEquals(30, date.getUTCMinutes());
assertEquals(42, date.getUTCSeconds());
+// Can deal with '-' vs '/'.
+date = dtf.v8Parse('2-4-74 12:30:42 am');
+assertEquals(1974, date.getUTCFullYear());
+assertEquals(1, date.getUTCMonth());
+assertEquals(4, date.getUTCDate());
+assertEquals(0, date.getUTCHours());
+assertEquals(30, date.getUTCMinutes());
+assertEquals(42, date.getUTCSeconds());
+
// AM/PM were not specified.
-assertEquals(undefined, dtf.v8Parse('2/4/74 12:30:12'));
+assertEquals(undefined, dtf.v8Parse('2/4/74 12:30:42'));
// Time was not specified.
assertEquals(undefined, dtf.v8Parse('2/4/74'));
// Month is numeric, so it fails on "Feb".
assertEquals(undefined, dtf.v8Parse('Feb 4th 1974'));
-
-// Wrong date delimiter.
-assertEquals(undefined, dtf.v8Parse('2-4-74 12:30:12 am'));
diff --git a/test/intl/intl.status b/test/intl/intl.status
index 02ee26b..7ef6b0d 100644
--- a/test/intl/intl.status
+++ b/test/intl/intl.status
@@ -29,12 +29,6 @@
[ALWAYS, {
# TODO(jochen): The following test is flaky.
'overrides/caching': [PASS, FAIL],
-
- # BUG(v8:3454).
- 'date-format/parse-MMMdy': [FAIL],
- 'date-format/parse-mdyhms': [FAIL],
- 'number-format/parse-decimal': [FAIL],
- 'number-format/parse-percent': [FAIL],
}], # ALWAYS
['arch == arm64 and mode == debug and simulator_run == True', {
diff --git a/test/intl/number-format/parse-decimal.js b/test/intl/number-format/parse-decimal.js
index ea3f8dd..62f4728 100644
--- a/test/intl/number-format/parse-decimal.js
+++ b/test/intl/number-format/parse-decimal.js
@@ -24,16 +24,29 @@
// 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.
+//
+// Flags: --intl-extra
var nf = new Intl.NumberFormat(['en'], {style: 'decimal'});
assertEquals(123.43, nf.v8Parse('123.43'));
assertEquals(123, nf.v8Parse('123'));
assertEquals(NaN, nf.v8Parse(NaN));
-assertEquals(12323, nf.v8Parse('123,23'));
-assertEquals(12323.456, nf.v8Parse('123,23.456'));
-assertEquals(12323.456, nf.v8Parse('0000000123,23.456'));
-assertEquals(-12323.456, nf.v8Parse('-123,23.456'));
+assertEquals(12323, nf.v8Parse('12,323'));
+assertEquals(12323, nf.v8Parse('12323'));
+assertEquals(12323.456, nf.v8Parse('12,323.456'));
+assertEquals(12323.456, nf.v8Parse('000000012323.456'));
+assertEquals(12323.456, nf.v8Parse('000,000,012,323.456'));
+assertEquals(-12323.456, nf.v8Parse('-12,323.456'));
-// Scientific notation gets ignored.
-assertEquals(123.456, nf.v8Parse('123.456e-3'));
+assertEquals(12323, nf.v8Parse('000000012323'));
+assertEquals(12323, nf.v8Parse('000,000,012,323'));
+assertEquals(undefined, nf.v8Parse('000000012,323.456'));
+
+// not tolerant of a misplaced thousand separator
+assertEquals(undefined, nf.v8Parse('123,23.456'));
+assertEquals(undefined, nf.v8Parse('0000000123,23.456'));
+assertEquals(undefined, nf.v8Parse('-123,23.456'));
+
+// Scientific notation is supported.
+assertEquals(0.123456, nf.v8Parse('123.456e-3'));
diff --git a/test/intl/number-format/parse-percent.js b/test/intl/number-format/parse-percent.js
index 4964da4..0dc36d3 100644
--- a/test/intl/number-format/parse-percent.js
+++ b/test/intl/number-format/parse-percent.js
@@ -25,12 +25,22 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Flags: --intl-extra
+
var nf = new Intl.NumberFormat(['en'], {style: 'percent'});
assertEquals(1.2343, nf.v8Parse('123.43%'));
assertEquals(1.23, nf.v8Parse('123%'));
assertEquals(NaN, nf.v8Parse(NaN));
-assertEquals(123.23, nf.v8Parse('123,23%'));
-assertEquals(123.23456, nf.v8Parse('123,23.456%'));
-assertEquals(123.23456, nf.v8Parse('0000000123,23.456%'));
-assertEquals(-123.23456, nf.v8Parse('-123,23.456%'));
+assertEquals(123.23, nf.v8Parse('12,323%'));
+assertEquals(123.23456, nf.v8Parse('12,323.456%'));
+assertEquals(123.23456, nf.v8Parse('000000012323.456%'));
+assertEquals(-123.23456, nf.v8Parse('-12,323.456%'));
+
+// Not tolerant of misplaced group separators.
+assertEquals(undefined, nf.v8Parse('123,23%'));
+assertEquals(undefined, nf.v8Parse('123,23.456%'));
+assertEquals(undefined, nf.v8Parse('0000000123,23.456%'));
+assertEquals(undefined, nf.v8Parse('-123,23.456%'));
+assertEquals(undefined, nf.v8Parse('0000000123,23.456%'));
+assertEquals(undefined, nf.v8Parse('-123,23.456%'));
diff --git a/test/js-perf-test/Generators/generators.js b/test/js-perf-test/Generators/generators.js
new file mode 100644
index 0000000..d49dee3
--- /dev/null
+++ b/test/js-perf-test/Generators/generators.js
@@ -0,0 +1,131 @@
+// 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.
+
+
+new BenchmarkSuite('Generators', [1000], [
+ new Benchmark('Basic', false, false, 0, Basic),
+ new Benchmark('Loop', false, false, 0, Loop),
+ new Benchmark('Input', false, false, 0, Input),
+ new Benchmark('YieldStar', false, false, 0, YieldStar),
+]);
+
+
+// ----------------------------------------------------------------------------
+// Benchmark: Basic
+// ----------------------------------------------------------------------------
+
+function* five() {
+ yield 1;
+ yield 2;
+ yield 3;
+ yield 4;
+ yield 5;
+}
+
+function Basic() {
+ let g = five();
+ let sum = 0;
+ sum += g.next().value;
+ sum += g.next().value;
+ sum += g.next().value;
+ sum += g.next().value;
+ sum += g.next().value;
+ if (sum != 15 || !g.next().done) throw "wrong";
+}
+
+
+// ----------------------------------------------------------------------------
+// Benchmark: Loop
+// ----------------------------------------------------------------------------
+
+function* fibonacci() {
+ let x = 0;
+ let y = 1;
+ yield x;
+ while (true) {
+ yield y;
+ let tmp = x;
+ x = y;
+ y += tmp;
+ }
+}
+
+function Loop() {
+ let n = 0;
+ let x;
+ for (x of fibonacci()) {
+ if (++n === 42) break;
+ }
+ if (x != 165580141) throw "wrong";
+}
+
+
+
+// ----------------------------------------------------------------------------
+// Benchmark: Input
+// ----------------------------------------------------------------------------
+
+function* multiples(x) {
+ let skip = function.sent || 0;
+ let next = 0;
+ while (true) {
+ if (skip === 0) {
+ skip = yield next;
+ } else {
+ skip--;
+ }
+ next += x;
+ }
+}
+
+function Input() {
+ let g = multiples(3);
+ results = [g.next(2), g.next(0), g.next(5), g.next(10)];
+ if (results.slice(-1)[0].value != 60) throw "wrong";
+}
+
+
+// ----------------------------------------------------------------------------
+// Benchmark: YieldStar
+// ----------------------------------------------------------------------------
+
+function* infix(node) {
+ if (node) {
+ yield* infix(node.left);
+ yield node.label;
+ yield* infix(node.right);
+ }
+}
+
+class Node {
+ constructor(label, left, right) {
+ this.label = label;
+ this.left = left;
+ this.right = right;
+ }
+}
+
+function YieldStar() {
+ let tree = new Node(1,
+ new Node(2,
+ new Node(3,
+ new Node(4,
+ new Node(16,
+ new Node(5,
+ new Node(23,
+ new Node(0),
+ new Node(17)),
+ new Node(44, new Node(20)))),
+ new Node(7,
+ undefined,
+ new Node(23,
+ new Node(0),
+ new Node(41, undefined, new Node(11))))),
+ new Node(8)),
+ new Node(5)),
+ new Node(6, undefined, new Node(7)));
+ let labels = [...(infix(tree))];
+ // 0,23,17,5,20,44,16,4,7,0,23,41,11,3,8,2,5,1,6,7
+ if (labels[0] != 0) throw "wrong";
+}
diff --git a/test/js-perf-test/Generators/run.js b/test/js-perf-test/Generators/run.js
new file mode 100644
index 0000000..6feb6f7
--- /dev/null
+++ b/test/js-perf-test/Generators/run.js
@@ -0,0 +1,26 @@
+// 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.
+
+
+load('../base.js');
+load('generators.js');
+
+var success = true;
+
+function PrintResult(name, result) {
+ print(name + '-Generators(Score): ' + result);
+}
+
+
+function PrintError(name, error) {
+ PrintResult(name, error);
+ success = false;
+}
+
+
+BenchmarkSuite.config.doWarmup = undefined;
+BenchmarkSuite.config.doDeterministic = undefined;
+
+BenchmarkSuite.RunSuites({ NotifyResult: PrintResult,
+ NotifyError: PrintError });
diff --git a/test/js-perf-test/JSTests.json b/test/js-perf-test/JSTests.json
index f8ab369..ed471bb 100644
--- a/test/js-perf-test/JSTests.json
+++ b/test/js-perf-test/JSTests.json
@@ -9,6 +9,40 @@
"resources": ["base.js"],
"tests": [
{
+ "name": "Generators",
+ "path": ["Generators"],
+ "main": "run.js",
+ "resources": ["generators.js"],
+ "flags": ["--harmony-function-sent"],
+ "results_regexp": "^Generators\\-Generators\\(Score\\): (.+)$"
+ },
+ {
+ "name": "GeneratorsIgnition",
+ "path": ["Generators"],
+ "main": "run.js",
+ "resources": ["generators.js"],
+ "flags": [
+ "--harmony-function-sent",
+ "--ignition",
+ "--ignition-generators"
+ ],
+ "results_regexp": "^Generators\\-Generators\\(Score\\): (.+)$"
+ },
+ {
+ "name": "GeneratorsIgnitionTurbofan",
+ "path": ["Generators"],
+ "main": "run.js",
+ "resources": ["generators.js"],
+ "flags": [
+ "--harmony-function-sent",
+ "--ignition",
+ "--ignition-generators",
+ "--turbo",
+ "--turbo-from-bytecode"
+ ],
+ "results_regexp": "^Generators\\-Generators\\(Score\\): (.+)$"
+ },
+ {
"name": "RestParameters",
"path": ["RestParameters"],
"main": "run.js",
diff --git a/test/memory/Memory.json b/test/memory/Memory.json
index 1cdc148..c6b8cd5 100644
--- a/test/memory/Memory.json
+++ b/test/memory/Memory.json
@@ -12,7 +12,7 @@
},
{
"name": "ReservedMemoryContext",
- "results_regexp": "(\\d+) bytes per context$"
+ "results_regexp": "(\\d+) bytes per context #0$"
},
{
"name": "SnapshotSizeStartup",
@@ -20,7 +20,7 @@
},
{
"name": "SnapshotSizeContext",
- "results_regexp": "(\\d+) bytes for context$"
+ "results_regexp": "(\\d+) bytes for context #0$"
}
]
}
diff --git a/test/message/generators-throw1.js b/test/message/generators-throw1.js
new file mode 100644
index 0000000..f544d33
--- /dev/null
+++ b/test/message/generators-throw1.js
@@ -0,0 +1,9 @@
+// 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.
+//
+// Flags: --ignition-generators
+
+function* f() { yield }
+
+f().throw(42);
diff --git a/test/message/generators-throw1.out b/test/message/generators-throw1.out
new file mode 100644
index 0000000..aeb9645
--- /dev/null
+++ b/test/message/generators-throw1.out
@@ -0,0 +1,3 @@
+*%(basename)s:7: 42
+function* f() { yield }
+ ^
diff --git a/test/message/generators-throw2.js b/test/message/generators-throw2.js
new file mode 100644
index 0000000..b805bbc
--- /dev/null
+++ b/test/message/generators-throw2.js
@@ -0,0 +1,11 @@
+// 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.
+//
+// Flags: --ignition-generators
+
+function* f() { yield }
+
+let g = f();
+g.next();
+g.throw(42);
diff --git a/test/message/generators-throw2.out b/test/message/generators-throw2.out
new file mode 100644
index 0000000..96353a5
--- /dev/null
+++ b/test/message/generators-throw2.out
@@ -0,0 +1,3 @@
+*%(basename)s:7: 42
+function* f() { yield }
+ ^
diff --git a/test/message/instanceof-noncallable.js b/test/message/instanceof-noncallable.js
index 571a2b0..d82b416 100644
--- a/test/message/instanceof-noncallable.js
+++ b/test/message/instanceof-noncallable.js
@@ -25,6 +25,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --harmony-instanceof
+
1 instanceof {};
diff --git a/test/message/instanceof-nonobject.js b/test/message/instanceof-nonobject.js
index 4715257..ef8e0ae 100644
--- a/test/message/instanceof-nonobject.js
+++ b/test/message/instanceof-nonobject.js
@@ -25,6 +25,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --harmony-instanceof
+
1 instanceof 2;
diff --git a/test/message/message.status b/test/message/message.status
index 051911c..e4db83d 100644
--- a/test/message/message.status
+++ b/test/message/message.status
@@ -27,8 +27,6 @@
[
[ALWAYS, {
- # All tests in the bug directory are expected to fail.
- 'bugs/*': [FAIL],
# We don't parse RegExps at scanning time, so we can't fail on octal
# escapes (we need to parse to distinguish octal escapes from valid
# back-references).
diff --git a/test/mjsunit/array-sort.js b/test/mjsunit/array-sort.js
index ae9f6ef..fdd2333 100644
--- a/test/mjsunit/array-sort.js
+++ b/test/mjsunit/array-sort.js
@@ -479,3 +479,68 @@
}
}
TestSortOnProxy();
+
+
+// Test special prototypes
+(function testSortSpecialPrototypes() {
+ function test(proto, length, expected) {
+ var result = {
+ length: length,
+ __proto__: proto,
+ };
+ Array.prototype.sort.call(result);
+ assertEquals(expected.length, result.length, "result.length");
+ for (var i = 0; i<expected.length; i++) {
+ assertEquals(expected[i], result[i], "result["+i+"]");
+ }
+ }
+
+ (function fast() {
+ // Fast elements, non-empty
+ test(arguments, 0, []);
+ test(arguments, 1, [2]);
+ test(arguments, 2, [1, 2]);
+ test(arguments, 4, [1, 2, 3, 4]);
+ delete arguments[0]
+ // sort copies down the properties to the receiver, hence result[1]
+ // is read on the arguments through the hole on the receiver.
+ test(arguments, 2, [1, 1]);
+ arguments[0] = undefined;
+ test(arguments, 2, [1, undefined]);
+ })(2, 1, 4, 3);
+
+ (function fastSloppy(a) {
+ // Fast sloppy
+ test(arguments, 0, []);
+ test(arguments, 1, [2]);
+ test(arguments, 2, [1, 2]);
+ delete arguments[0]
+ test(arguments, 2, [1, 1]);
+ arguments[0] = undefined;
+ test(arguments, 2, [1, undefined]);
+ })(2, 1);
+
+ (function fastEmpty() {
+ test(arguments, 0, []);
+ test(arguments, 1, [undefined]);
+ test(arguments, 2, [undefined, undefined]);
+ })();
+
+ (function stringWrapper() {
+ // cannot redefine string wrapper properties
+ assertThrows(() => test(new String('cba'), 3, []), TypeError);
+ })();
+
+ (function typedArrys() {
+ test(new Int32Array(0), 0, []);
+ test(new Int32Array(1), 1, [0]);
+ var array = new Int32Array(3);
+ array[0] = 2;
+ array[1] = 1;
+ array[2] = 3;
+ test(array, 1, [2]);
+ test(array, 2, [1, 2]);
+ test(array, 3, [1, 2, 3]);
+ })()
+
+})();
diff --git a/test/mjsunit/asm/construct-double.js b/test/mjsunit/asm/construct-double.js
deleted file mode 100644
index 8bb5000..0000000
--- a/test/mjsunit/asm/construct-double.js
+++ /dev/null
@@ -1,33 +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.
-
-// Flags: --allow-natives-syntax
-
-var stdlib = this;
-var foreign = {};
-var heap = new ArrayBuffer(64 * 1024);
-
-
-var m = (function(stdlib, foreign, heap) {
- "use asm";
- function cd1(i, j) {
- i = i|0;
- j = j|0;
- return +%_ConstructDouble(i, j);
- }
- function cd2(i) {
- i = i|0;
- return +%_ConstructDouble(0, i);
- }
- return { cd1: cd1, cd2: cd2 };
-})(stdlib, foreign, heap);
-
-assertEquals(0.0, m.cd1(0, 0));
-assertEquals(%ConstructDouble(0, 1), m.cd2(1));
-for (var i = -2147483648; i < 2147483648; i += 3999773) {
- assertEquals(%ConstructDouble(0, i), m.cd2(i));
- for (var j = -2147483648; j < 2147483648; j += 3999773) {
- assertEquals(%ConstructDouble(i, j), m.cd1(i, j));
- }
-}
diff --git a/test/mjsunit/compiler/dont-constant-fold-deopting-checks.js b/test/mjsunit/compiler/dont-constant-fold-deopting-checks.js
new file mode 100644
index 0000000..02bd8d9
--- /dev/null
+++ b/test/mjsunit/compiler/dont-constant-fold-deopting-checks.js
@@ -0,0 +1,10 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+function bar(a) { a[0](true); }
+function foo(a) { return bar(1); }
+%OptimizeFunctionOnNextCall(foo);
+assertThrows(function() {bar([foo])}, TypeError);
diff --git a/test/mjsunit/compiler/inline-dead-jscreate.js b/test/mjsunit/compiler/inline-dead-jscreate.js
new file mode 100644
index 0000000..a977875
--- /dev/null
+++ b/test/mjsunit/compiler/inline-dead-jscreate.js
@@ -0,0 +1,14 @@
+// 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.
+
+var bar = 0;
+
+function baz() { return this; }
+
+function foo() {
+ bar += 1;
+ if (bar === 2) throw new baz();
+}
+
+foo();
diff --git a/test/mjsunit/compiler/optimized-instanceof-1.js b/test/mjsunit/compiler/optimized-instanceof-1.js
index 538b0ef..242b4be 100644
--- a/test/mjsunit/compiler/optimized-instanceof-1.js
+++ b/test/mjsunit/compiler/optimized-instanceof-1.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --allow-natives-syntax --harmony-instanceof
+// Flags: --allow-natives-syntax
function F() {}
var f = new F
diff --git a/test/mjsunit/compiler/optimized-instanceof-2.js b/test/mjsunit/compiler/optimized-instanceof-2.js
index 80bbdcd..38a35b7 100644
--- a/test/mjsunit/compiler/optimized-instanceof-2.js
+++ b/test/mjsunit/compiler/optimized-instanceof-2.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --allow-natives-syntax --harmony-instanceof
+// Flags: --allow-natives-syntax
function F() {}
var f = new F
diff --git a/test/mjsunit/compiler/regress-5074.js b/test/mjsunit/compiler/regress-5074.js
new file mode 100644
index 0000000..903b54a
--- /dev/null
+++ b/test/mjsunit/compiler/regress-5074.js
@@ -0,0 +1,18 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+var s = [,0.1];
+
+function foo(a, b) {
+ var x = s[a];
+ s[1] = 0.1;
+ return x + b;
+}
+
+assertEquals(2.1, foo(1, 2));
+assertEquals(2.1, foo(1, 2));
+%OptimizeFunctionOnNextCall(foo);
+assertEquals("undefined2", foo(0, "2"));
diff --git a/test/mjsunit/compiler/regress-5100.js b/test/mjsunit/compiler/regress-5100.js
new file mode 100644
index 0000000..694cd8a
--- /dev/null
+++ b/test/mjsunit/compiler/regress-5100.js
@@ -0,0 +1,51 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+var a = [0, 1];
+a["true"] = "true";
+a["false"] = "false";
+a["null"] = "null";
+a["undefined"] = "undefined";
+
+// Ensure we don't accidentially truncate true when used to index arrays.
+(function() {
+ function f(x) { return a[x]; }
+
+ assertEquals(0, f(0));
+ assertEquals(0, f(0));
+ %OptimizeFunctionOnNextCall(f);
+ assertEquals("true", f(true));
+})();
+
+// Ensure we don't accidentially truncate false when used to index arrays.
+(function() {
+ function f( x) { return a[x]; }
+
+ assertEquals(0, f(0));
+ assertEquals(0, f(0));
+ %OptimizeFunctionOnNextCall(f);
+ assertEquals("false", f(false));
+})();
+
+// Ensure we don't accidentially truncate null when used to index arrays.
+(function() {
+ function f( x) { return a[x]; }
+
+ assertEquals(0, f(0));
+ assertEquals(0, f(0));
+ %OptimizeFunctionOnNextCall(f);
+ assertEquals("null", f(null));
+})();
+
+// Ensure we don't accidentially truncate undefined when used to index arrays.
+(function() {
+ function f( x) { return a[x]; }
+
+ assertEquals(0, f(0));
+ assertEquals(0, f(0));
+ %OptimizeFunctionOnNextCall(f);
+ assertEquals("undefined", f(undefined));
+})();
diff --git a/test/mjsunit/compiler/regress-5129.js b/test/mjsunit/compiler/regress-5129.js
new file mode 100644
index 0000000..1d100ab
--- /dev/null
+++ b/test/mjsunit/compiler/regress-5129.js
@@ -0,0 +1,15 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+function foo($a,$b) {
+ $a = $a|0;
+ $b = $b|0;
+ var $sub = $a - $b;
+ return ($sub|0) < 0;
+}
+
+%OptimizeFunctionOnNextCall(foo);
+assertTrue(foo(0x7fffffff,-1));
diff --git a/test/mjsunit/compiler/regress-621423.js b/test/mjsunit/compiler/regress-621423.js
new file mode 100644
index 0000000..962176f
--- /dev/null
+++ b/test/mjsunit/compiler/regress-621423.js
@@ -0,0 +1,21 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+var a = [0, ""];
+a[0] = 0;
+
+function g(array) {
+ array[1] = undefined;
+}
+
+function f() {
+ g(function() {});
+ g(a);
+}
+
+f();
+%OptimizeFunctionOnNextCall(f);
+f();
diff --git a/test/mjsunit/compiler/regress-number-is-hole-nan.js b/test/mjsunit/compiler/regress-number-is-hole-nan.js
new file mode 100644
index 0000000..368c837
--- /dev/null
+++ b/test/mjsunit/compiler/regress-number-is-hole-nan.js
@@ -0,0 +1,14 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+var a = [, 2.121736758e-314];
+
+function foo() { return a[1]; }
+
+assertEquals(2.121736758e-314, foo());
+assertEquals(2.121736758e-314, foo());
+%OptimizeFunctionOnNextCall(foo);
+assertEquals(2.121736758e-314, foo());
diff --git a/test/mjsunit/compiler/regress-store-holey-double-array.js b/test/mjsunit/compiler/regress-store-holey-double-array.js
new file mode 100644
index 0000000..8123198
--- /dev/null
+++ b/test/mjsunit/compiler/regress-store-holey-double-array.js
@@ -0,0 +1,43 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+(function StoreHoleBitPattern() {
+ function g(src, dst, i) {
+ dst[i] = src[i];
+ }
+
+ var b = new ArrayBuffer(16);
+ var i32 = new Int32Array(b);
+ i32[0] = 0xFFF7FFFF;
+ i32[1] = 0xFFF7FFFF;
+ i32[3] = 0xFFF7FFFF;
+ i32[4] = 0xFFF7FFFF;
+ var f64 = new Float64Array(b);
+
+ var a = [,0.1];
+
+ g(f64, a, 1);
+ g(f64, a, 1);
+ %OptimizeFunctionOnNextCall(g);
+ g(f64, a, 0);
+
+ assertTrue(Number.isNaN(a[0]));
+})();
+
+
+(function ConvertHoleToNumberAndStore() {
+ function g(a, i) {
+ var x = a[i];
+ a[i] = +x;
+ }
+
+ var a=[,0.1];
+ g(a, 1);
+ g(a, 1);
+ %OptimizeFunctionOnNextCall(g);
+ g(a, 0);
+ assertTrue(Number.isNaN(a[0]));
+})();
diff --git a/test/mjsunit/compiler/regress-string-to-number-add.js b/test/mjsunit/compiler/regress-string-to-number-add.js
new file mode 100644
index 0000000..e872401
--- /dev/null
+++ b/test/mjsunit/compiler/regress-string-to-number-add.js
@@ -0,0 +1,15 @@
+// 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.
+
+// Flags: --allow-natives-syntax --turbo-type-feedback
+
+function f(x) {
+ var s = x ? "0" : "1";
+ return 1 + Number(s);
+}
+
+f(0);
+f(0);
+%OptimizeFunctionOnNextCall(f);
+assertEquals(2, f(0));
diff --git a/test/mjsunit/compiler/regress-truncate-number-or-undefined-to-float64.js b/test/mjsunit/compiler/regress-truncate-number-or-undefined-to-float64.js
new file mode 100644
index 0000000..1dc3042
--- /dev/null
+++ b/test/mjsunit/compiler/regress-truncate-number-or-undefined-to-float64.js
@@ -0,0 +1,19 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+function g(a, b) {
+ a = +a;
+ if (b) {
+ a = undefined;
+ }
+ print(a);
+ return +a;
+}
+
+g(0);
+g(0);
+%OptimizeFunctionOnNextCall(g);
+assertTrue(Number.isNaN(g(0, true)));
diff --git a/test/mjsunit/compiler/turbo-number-feedback.js b/test/mjsunit/compiler/turbo-number-feedback.js
new file mode 100644
index 0000000..059a0ca
--- /dev/null
+++ b/test/mjsunit/compiler/turbo-number-feedback.js
@@ -0,0 +1,58 @@
+// 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.
+
+// Flags: --allow-natives-syntax --turbo-type-feedback
+
+(function AddSubtractSmis() {
+ function f0(a, b, c) {
+ return a + b - c;
+ }
+
+ assertEquals(4, f0(3, 2, 1));
+ assertEquals(4, f0(3, 2, 1));
+ %OptimizeFunctionOnNextCall(f0);
+ assertEquals(4, f0(3, 2, 1));
+})();
+
+(function AddSubtractDoubles() {
+ function f1(a, b, c) {
+ return a + b - c;
+ }
+
+ assertEquals(4.5, f1(3.5, 2.5, 1.5));
+ assertEquals(4.5, f1(3.5, 2.5, 1.5));
+ %OptimizeFunctionOnNextCall(f1);
+ assertEquals(4.5, f1(3.5, 2.5, 1.5));
+ assertEquals(4, f1(3, 2, 1));
+ assertTrue(isNaN(f1(3, 2, undefined)));
+ assertTrue(isNaN(f1(3, undefined, 1)));
+})();
+
+(function CheckUint32ToInt32Conv() {
+ function f2(a) {
+ return (a >>> 0) + 1;
+ }
+
+ assertEquals(1, f2(0));
+ assertEquals(1, f2(0));
+ %OptimizeFunctionOnNextCall(f2);
+ assertEquals(1, f2(0));
+ assertEquals(4294967295, f2(-2));
+})();
+
+(function CheckFloat64ToInt32Conv() {
+ function f3(a, b) {
+ var x = 0;
+ if (a) {
+ x = 0.5;
+ }
+ return x + b;
+ }
+
+ assertEquals(1, f3(0, 1));
+ assertEquals(1, f3(0, 1));
+ %OptimizeFunctionOnNextCall(f3);
+ assertEquals(1, f3(0, 1));
+ assertEquals(1.5, f3(1, 1));
+})();
diff --git a/test/mjsunit/debug-generator-break-on-stack.js b/test/mjsunit/debug-generator-break-on-stack.js
new file mode 100644
index 0000000..b743488
--- /dev/null
+++ b/test/mjsunit/debug-generator-break-on-stack.js
@@ -0,0 +1,46 @@
+// 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.
+
+// Flags: --expose-debug-as debug --ignition-generators
+
+var Debug = debug.Debug;
+
+var break_count = 0;
+var exception = null;
+
+function listener(event, exec_state, event_data, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ break_count++;
+ var line = exec_state.frame(0).sourceLineText();
+ print(line);
+ assertTrue(line.indexOf(`B${break_count}`) > 0);
+ } catch (e) {
+ exception = e;
+ }
+}
+
+
+function* g() {
+ setbreaks();
+ yield 1; // B1
+}
+
+function* f() {
+ yield* g();
+ return 2; // B2
+}
+
+function setbreaks() {
+ Debug.setListener(listener);
+ Debug.setBreakPoint(g, 2);
+ Debug.setBreakPoint(f, 2);
+}
+
+for (let _ of f()) { }
+
+assertEquals(2, break_count);
+assertNull(exception);
+
+Debug.setListener(null);
diff --git a/test/mjsunit/debug-generator-break.js b/test/mjsunit/debug-generator-break.js
new file mode 100644
index 0000000..4ab601b
--- /dev/null
+++ b/test/mjsunit/debug-generator-break.js
@@ -0,0 +1,44 @@
+// 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.
+
+// Flags: --expose-debug-as debug --ignition-generators
+
+var Debug = debug.Debug;
+
+var break_count = 0;
+var exception = null;
+
+function listener(event, exec_state, event_data, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ break_count++;
+ var line = exec_state.frame(0).sourceLineText();
+ assertTrue(line.indexOf(`B${break_count}`) > 0);
+ } catch (e) {
+ exception = e;
+ }
+}
+
+Debug.setListener(listener);
+
+function* g() {
+ yield 1;
+}
+
+function* f() {
+ yield* g(); // B1
+ assertEquals(2, break_count); // B2
+ return 1; // B3
+}
+
+Debug.setBreakPoint(f, 1);
+Debug.setBreakPoint(f, 2);
+Debug.setBreakPoint(f, 3);
+
+for (let _ of f()) { }
+
+assertEquals(3, break_count);
+assertNull(exception);
+
+Debug.setListener(null);
diff --git a/test/mjsunit/debug-handle.js b/test/mjsunit/debug-handle.js
index 1582b9f..ca02592 100644
--- a/test/mjsunit/debug-handle.js
+++ b/test/mjsunit/debug-handle.js
@@ -108,7 +108,7 @@
var handle_a = evaluateRequest(exec_state, '{"expression":"b","frame":1}');
assertEquals(handle_o, handle_a);
assertEquals(handle_a, handle_b);
- assertFalse(handle_o == handle_p, "o and p have he same handle");
+ assertFalse(handle_o == handle_p, "o and p have the same handle");
var response;
var count;
@@ -140,7 +140,7 @@
var handle_g = evaluateRequest(exec_state, '{"expression":"g"}');
var handle_caller = evaluateRequest(exec_state, '{"expression":"f.caller"}');
- assertFalse(handle_f == handle_g, "f and g have he same handle");
+ assertFalse(handle_f == handle_g, "f and g have the same handle");
assertEquals(handle_g, handle_caller, "caller for f should be g");
response = lookupRequest(exec_state, '{"handles":[' + handle_f + ']}', true);
diff --git a/test/mjsunit/debug-script.js b/test/mjsunit/debug-script.js
index 5396415..3bedb74 100644
--- a/test/mjsunit/debug-script.js
+++ b/test/mjsunit/debug-script.js
@@ -84,11 +84,6 @@
assertEquals('native math.js', math_script.name);
assertEquals(Debug.ScriptType.Native, math_script.type);
-// Test a builtins delay loaded script.
-var date_delay_script = Debug.findScript('native json.js');
-assertEquals('native json.js', date_delay_script.name);
-assertEquals(Debug.ScriptType.Native, date_delay_script.type);
-
// Test a debugger script.
var debug_delay_script = Debug.findScript('native debug.js');
assertEquals('native debug.js', debug_delay_script.name);
diff --git a/test/mjsunit/debug-sourceinfo.js b/test/mjsunit/debug-sourceinfo.js
index cb41107..b79fb8e 100644
--- a/test/mjsunit/debug-sourceinfo.js
+++ b/test/mjsunit/debug-sourceinfo.js
@@ -63,12 +63,11 @@
// This is the last position in the entire file (note: this equals
// file size of <debug-sourceinfo.js> - 1, since starting at 0).
-var last_position = 11519;
+var last_position = 8126;
// This is the last line of entire file (note: starting at 0).
-var last_line = 269;
-// This is the last column of last line (note: starting at 0 and +1, due
-// to trailing <LF>).
-var last_column = 1;
+var last_line = 200;
+// This is the last column of last line (note: starting at 0).
+var last_column = 71;
// This magic number is the length or the first line comment (actually number
// of characters before 'function a(...'.
@@ -168,66 +167,6 @@
assertEquals(11, script.locationFromPosition(start_d).line - comment_lines);
assertEquals(10, script.locationFromPosition(start_d).column);
-// Test first line.
-assertEquals(0, script.locationFromLine().position);
-assertEquals(0, script.locationFromLine().line);
-assertEquals(0, script.locationFromLine().column);
-assertEquals(0, script.locationFromLine(0).position);
-assertEquals(0, script.locationFromLine(0).line);
-assertEquals(0, script.locationFromLine(0).column);
-
-// Test first line column 1.
-assertEquals(1, script.locationFromLine(0, 1).position);
-assertEquals(0, script.locationFromLine(0, 1).line);
-assertEquals(1, script.locationFromLine(0, 1).column);
-
-// Test first line offset 1.
-assertEquals(1, script.locationFromLine(0, 0, 1).position);
-assertEquals(0, script.locationFromLine(0, 0, 1).line);
-assertEquals(1, script.locationFromLine(0, 0, 1).column);
-
-// Test offset function a().
-assertEquals(start_a, script.locationFromLine(void 0, void 0, start_a).position);
-assertEquals(0, script.locationFromLine(void 0, void 0, start_a).line - comment_lines);
-assertEquals(10, script.locationFromLine(void 0, void 0, start_a).column);
-assertEquals(start_a, script.locationFromLine(0, void 0, start_a).position);
-assertEquals(0, script.locationFromLine(0, void 0, start_a).line - comment_lines);
-assertEquals(10, script.locationFromLine(0, void 0, start_a).column);
-assertEquals(start_a, script.locationFromLine(0, 0, start_a).position);
-assertEquals(0, script.locationFromLine(0, 0, start_a).line - comment_lines);
-assertEquals(10, script.locationFromLine(0, 0, start_a).column);
-
-// Test second line offset function a().
-assertEquals(start_a + 13, script.locationFromLine(1, 0, start_a).position);
-assertEquals(1, script.locationFromLine(1, 0, start_a).line - comment_lines);
-assertEquals(0, script.locationFromLine(1, 0, start_a).column);
-
-// Test second line column 2 offset function a().
-assertEquals(start_a + 13 + 1, script.locationFromLine(1, 1, start_a).position);
-assertEquals(1, script.locationFromLine(1, 2, start_a).line - comment_lines);
-assertEquals(2, script.locationFromLine(1, 2, start_a).column);
-
-// Test offset function b().
-assertEquals(start_b, script.locationFromLine(0, 0, start_b).position);
-assertEquals(1, script.locationFromLine(0, 0, start_b).line - comment_lines);
-assertEquals(13, script.locationFromLine(0, 0, start_b).column);
-
-// Test second line offset function b().
-assertEquals(start_b + 5, script.locationFromLine(1, 0, start_b).position);
-assertEquals(2, script.locationFromLine(1, 0, start_b).line - comment_lines);
-assertEquals(0, script.locationFromLine(1, 0, start_b).column);
-
-// Test second line column 10 offset function b().
-assertEquals(start_b + 5 + 10, script.locationFromLine(1, 10, start_b).position);
-assertEquals(2, script.locationFromLine(1, 10, start_b).line - comment_lines);
-assertEquals(10, script.locationFromLine(1, 10, start_b).column);
-
-// Test second line column 11 offset function b. Second line in b is 10 long
-// using column 11 wraps to next line.
-assertEquals(start_b + 5 + 11, script.locationFromLine(1, 11, start_b).position);
-assertEquals(3, script.locationFromLine(1, 11, start_b).line - comment_lines);
-assertEquals(0, script.locationFromLine(1, 11, start_b).column);
-
// Test the Debug.findSourcePosition which wraps SourceManager.
assertEquals(0 + start_a, Debug.findFunctionSourceLocation(a, 0, 0).position);
assertEquals(0 + start_b, Debug.findFunctionSourceLocation(b, 0, 0).position);
@@ -260,11 +199,3 @@
assertEquals(last_line + 1,
script.locationFromPosition(last_position + 1).line);
assertEquals(0, script.locationFromPosition(last_position + 1).column);
-
-// Test that script.sourceLine(line) works.
-var location;
-
-for (line = 0; line < num_lines_d; line++) {
- var line_content_regexp = new RegExp(" x = " + (line + 1));
- assertTrue(line_content_regexp.test(script.sourceLine(start_line_d + line)));
-}
diff --git a/test/mjsunit/debug-sourceslice.js b/test/mjsunit/debug-sourceslice.js
deleted file mode 100644
index db9a3e7..0000000
--- a/test/mjsunit/debug-sourceslice.js
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2008 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.
-
-// Flags: --expose-debug-as debug
-// Source lines for test.
-var lines = [ 'function a() { b(); };\n',
- 'function b() {\n',
- ' c(true);\n',
- '};\n',
- ' function c(x) {\n',
- ' if (x) {\n',
- ' return 1;\n',
- ' } else {\n',
- ' return 1;\n',
- ' }\n',
- ' };\n' ];
-
-// Build source by putting all lines together
-var source = '';
-for (var i = 0; i < lines.length; i++) {
- source += lines[i];
-}
-eval(source);
-
-// Flags: --expose-debug-as debug
-// Get the Debug object exposed from the debug context global object.
-Debug = debug.Debug
-
-// Get the script object from one of the functions in the source.
-var script = Debug.findScript(a);
-
-// Make sure that the source is as expected.
-assertEquals(source, script.source);
-assertEquals(source, script.sourceSlice().sourceText());
-
-// Try all possible line interval slices.
-for (var slice_size = 0; slice_size < lines.length; slice_size++) {
- for (var n = 0; n < lines.length - slice_size; n++) {
- var slice = script.sourceSlice(n, n + slice_size);
- assertEquals(n, slice.from_line);
- assertEquals(n + slice_size, slice.to_line);
-
- var text = slice.sourceText();
- var expected = '';
- for (var i = 0; i < slice_size; i++) {
- expected += lines[n + i];
- }
- assertEquals(expected, text);
- }
-}
diff --git a/test/mjsunit/dictionary-properties.js b/test/mjsunit/dictionary-properties.js
index 0659268..33360d7 100644
--- a/test/mjsunit/dictionary-properties.js
+++ b/test/mjsunit/dictionary-properties.js
@@ -39,7 +39,13 @@
SlowPrototype.prototype.bar = 2;
SlowPrototype.prototype.baz = 3;
delete SlowPrototype.prototype.baz;
-new SlowPrototype;
+assertFalse(%HasFastProperties(SlowPrototype.prototype));
+var slow_proto = new SlowPrototype;
+// ICs make prototypes fast.
+function ic() { return slow_proto.bar; }
+ic();
+ic();
+assertTrue(%HasFastProperties(slow_proto.__proto__));
// Prototypes stay fast even after deleting properties.
assertTrue(%HasFastProperties(SlowPrototype.prototype));
diff --git a/test/mjsunit/double-intrinsics.js b/test/mjsunit/double-intrinsics.js
index 16d6538..b50038e 100644
--- a/test/mjsunit/double-intrinsics.js
+++ b/test/mjsunit/double-intrinsics.js
@@ -7,10 +7,10 @@
function assertDoubleBits(hi, lo, x) {
hi = hi | 0;
lo = lo | 0;
- assertEquals(x, %_ConstructDouble(hi, lo));
+ assertEquals(x, %ConstructDouble(hi, lo));
assertEquals(hi, %_DoubleHi(x));
assertEquals(lo, %_DoubleLo(x));
- assertEquals(x, %_ConstructDouble(%_DoubleHi(x), %_DoubleLo(x)));
+ assertEquals(x, %ConstructDouble(%_DoubleHi(x), %_DoubleLo(x)));
}
diff --git a/test/mjsunit/harmony/array-species-constructor-accessor.js b/test/mjsunit/es6/array-species-constructor-accessor.js
similarity index 94%
rename from test/mjsunit/harmony/array-species-constructor-accessor.js
rename to test/mjsunit/es6/array-species-constructor-accessor.js
index 4c852f0..7ebf328 100644
--- a/test/mjsunit/harmony/array-species-constructor-accessor.js
+++ b/test/mjsunit/es6/array-species-constructor-accessor.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species --allow-natives-syntax
+// Flags: --allow-natives-syntax
// Overwriting the constructor of an instance updates the protector
diff --git a/test/mjsunit/harmony/array-species-constructor-delete.js b/test/mjsunit/es6/array-species-constructor-delete.js
similarity index 94%
rename from test/mjsunit/harmony/array-species-constructor-delete.js
rename to test/mjsunit/es6/array-species-constructor-delete.js
index f341282..fff22a2 100644
--- a/test/mjsunit/harmony/array-species-constructor-delete.js
+++ b/test/mjsunit/es6/array-species-constructor-delete.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species --allow-natives-syntax
+// Flags: --allow-natives-syntax
// Overwriting the constructor of an instance updates the protector
diff --git a/test/mjsunit/harmony/array-species-constructor.js b/test/mjsunit/es6/array-species-constructor.js
similarity index 94%
rename from test/mjsunit/harmony/array-species-constructor.js
rename to test/mjsunit/es6/array-species-constructor.js
index d766e09..0d888f4 100644
--- a/test/mjsunit/harmony/array-species-constructor.js
+++ b/test/mjsunit/es6/array-species-constructor.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species --allow-natives-syntax
+// Flags: --allow-natives-syntax
// Overwriting the constructor of an instance updates the protector
diff --git a/test/mjsunit/harmony/array-species-delete.js b/test/mjsunit/es6/array-species-delete.js
similarity index 94%
rename from test/mjsunit/harmony/array-species-delete.js
rename to test/mjsunit/es6/array-species-delete.js
index ba49414..16a2fa2 100644
--- a/test/mjsunit/harmony/array-species-delete.js
+++ b/test/mjsunit/es6/array-species-delete.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species --allow-natives-syntax
+// Flags: --allow-natives-syntax
// Overwriting the constructor of an instance updates the protector
diff --git a/test/mjsunit/harmony/array-species-modified.js b/test/mjsunit/es6/array-species-modified.js
similarity index 94%
rename from test/mjsunit/harmony/array-species-modified.js
rename to test/mjsunit/es6/array-species-modified.js
index 73c52b9..58feb31 100644
--- a/test/mjsunit/harmony/array-species-modified.js
+++ b/test/mjsunit/es6/array-species-modified.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species --allow-natives-syntax
+// Flags: --allow-natives-syntax
// Overwriting Array[Symbol.species] updates the protector
diff --git a/test/mjsunit/harmony/array-species-parent-constructor.js b/test/mjsunit/es6/array-species-parent-constructor.js
similarity index 94%
rename from test/mjsunit/harmony/array-species-parent-constructor.js
rename to test/mjsunit/es6/array-species-parent-constructor.js
index 347732e..b4fb1d5 100644
--- a/test/mjsunit/harmony/array-species-parent-constructor.js
+++ b/test/mjsunit/es6/array-species-parent-constructor.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species --allow-natives-syntax
+// Flags: --allow-natives-syntax
// Overwriting Array.prototype.constructor updates the protector
diff --git a/test/mjsunit/harmony/array-species-proto.js b/test/mjsunit/es6/array-species-proto.js
similarity index 94%
rename from test/mjsunit/harmony/array-species-proto.js
rename to test/mjsunit/es6/array-species-proto.js
index 70db751..6b55881 100644
--- a/test/mjsunit/harmony/array-species-proto.js
+++ b/test/mjsunit/es6/array-species-proto.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species --allow-natives-syntax
+// Flags: --allow-natives-syntax
// Overwriting an array instance's __proto__ updates the protector
diff --git a/test/mjsunit/harmony/array-species.js b/test/mjsunit/es6/array-species.js
similarity index 99%
rename from test/mjsunit/harmony/array-species.js
rename to test/mjsunit/es6/array-species.js
index 19ed1d8..25edf55 100644
--- a/test/mjsunit/harmony/array-species.js
+++ b/test/mjsunit/es6/array-species.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species
-
// Test the ES2015 @@species feature
'use strict';
diff --git a/test/mjsunit/harmony/arraybuffer-species.js b/test/mjsunit/es6/arraybuffer-species.js
similarity index 97%
rename from test/mjsunit/harmony/arraybuffer-species.js
rename to test/mjsunit/es6/arraybuffer-species.js
index 0445a4b..1ac6efb 100644
--- a/test/mjsunit/harmony/arraybuffer-species.js
+++ b/test/mjsunit/es6/arraybuffer-species.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species
-
// ArrayBuffer.prototype.slice makes subclass and checks length
class MyArrayBuffer extends ArrayBuffer { }
diff --git a/test/mjsunit/es6/block-eval-var-over-let.js b/test/mjsunit/es6/block-eval-var-over-let.js
index febc83f..b68dbdd 100644
--- a/test/mjsunit/es6/block-eval-var-over-let.js
+++ b/test/mjsunit/es6/block-eval-var-over-let.js
@@ -8,13 +8,13 @@
assertThrows(function() {
let x = 1;
eval('var x');
-}, TypeError);
+}, SyntaxError);
// If the eval is in its own block scope, throws
assertThrows(function() {
let y = 1;
{ eval('var y'); }
-}, TypeError);
+}, SyntaxError);
// If the let is in its own block scope, with the eval, throws
assertThrows(function() {
@@ -22,7 +22,7 @@
let x = 1;
eval('var x');
}
-}, TypeError);
+}, SyntaxError);
// Legal if the let is no longer visible
assertDoesNotThrow(function() {
@@ -37,13 +37,13 @@
assertThrows(function() {
const x = 1;
eval('var x');
-}, TypeError);
+}, SyntaxError);
// If the eval is in its own block scope, throws
assertThrows(function() {
const y = 1;
{ eval('var y'); }
-}, TypeError);
+}, SyntaxError);
// If the const is in its own block scope, with the eval, throws
assertThrows(function() {
@@ -51,7 +51,7 @@
const x = 1;
eval('var x');
}
-}, TypeError);
+}, SyntaxError);
// Legal if the const is no longer visible
assertDoesNotThrow(function() {
diff --git a/test/mjsunit/es6/classes-subclass-builtins.js b/test/mjsunit/es6/classes-subclass-builtins.js
index 7669ef3..dca514c 100644
--- a/test/mjsunit/es6/classes-subclass-builtins.js
+++ b/test/mjsunit/es6/classes-subclass-builtins.js
@@ -2,8 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --allow-natives-syntax --harmony-regexp-subclass
-// Flags: --expose-gc
+// Flags: --allow-natives-syntax --expose-gc
"use strict";
diff --git a/test/mjsunit/es6/debug-promises/async-task-event.js b/test/mjsunit/es6/debug-promises/async-task-event.js
index 88030a2..0b0fa1e 100644
--- a/test/mjsunit/es6/debug-promises/async-task-event.js
+++ b/test/mjsunit/es6/debug-promises/async-task-event.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --expose-debug-as debug
+// Flags: --expose-debug-as debug --allow-natives-syntax
Debug = debug.Debug;
@@ -16,8 +16,8 @@
"didHandle #1",
"willHandle #2",
"then #2",
- "enqueue #3",
"didHandle #2",
+ "enqueue #3",
"willHandle #3",
"didHandle #3"
];
@@ -58,4 +58,6 @@
});
resolver();
+%RunMicrotasks();
+
assertNull(exception);
diff --git a/test/mjsunit/es6/debug-promises/evaluate-across-microtasks.js b/test/mjsunit/es6/debug-promises/evaluate-across-microtasks.js
new file mode 100644
index 0000000..73718ee
--- /dev/null
+++ b/test/mjsunit/es6/debug-promises/evaluate-across-microtasks.js
@@ -0,0 +1,66 @@
+// 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.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax
+
+var Debug = debug.Debug;
+var listenerComplete = false;
+var exception = null;
+var count = 0;
+var log = [];
+var done = false;
+
+function LogX(x) {
+ var stored_count = count;
+ return function() {
+ log.push(`[${stored_count}] ${x}`);
+ };
+}
+
+function DebuggerStatement() {
+ log.push(`[${count}] debugger`);
+ if (count++ < 3) {
+ debugger;
+ }
+}
+
+function listener(event, exec_state, event_data, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var p = Promise.resolve();
+ var q = p.then(LogX("then 1"));
+ p.then(LogX("then 2"));
+ q.then(LogX("then 3"));
+ q.then(DebuggerStatement);
+ var r = q.then(() => { throw 1; });
+ r.catch(LogX("catch"));
+ listenerComplete = true;
+ } catch (e) {
+ exception = e;
+ print(e, e.stack);
+ quit(1);
+ };
+};
+
+// Add the debug event listener.
+Debug.setListener(listener);
+
+DebuggerStatement();
+LogX("start")();
+
+// Make sure that the debug event listener was invoked.
+assertTrue(listenerComplete);
+
+%RunMicrotasks();
+
+var expectation =
+ [ "[0] debugger", "[1] start", "[1] then 1",
+ "[1] then 2", "[1] then 3", "[1] debugger",
+ "[2] then 1", "[2] then 2", "[1] catch",
+ "[2] then 3", "[2] debugger", "[3] then 1",
+ "[3] then 2", "[2] catch", "[3] then 3",
+ "[3] debugger", "[3] catch",
+ ];
+
+assertEquals(expectation, log);
diff --git a/test/mjsunit/es6/debug-step-into-regexp-subclass.js b/test/mjsunit/es6/debug-step-into-regexp-subclass.js
index 599fe05..5e5eb47 100644
--- a/test/mjsunit/es6/debug-step-into-regexp-subclass.js
+++ b/test/mjsunit/es6/debug-step-into-regexp-subclass.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --expose-debug-as debug --harmony-regexp-subclass
+// Flags: --expose-debug-as debug
Debug = debug.Debug
diff --git a/test/mjsunit/es6/debug-stepin-generators.js b/test/mjsunit/es6/debug-stepin-generators.js
index 081dfb7..6e548b4 100644
--- a/test/mjsunit/es6/debug-stepin-generators.js
+++ b/test/mjsunit/es6/debug-stepin-generators.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --expose-debug-as debug
+// Flags: --expose-debug-as debug --ignition-generators
Debug = debug.Debug
var exception = null;
diff --git a/test/mjsunit/harmony/function-name.js b/test/mjsunit/es6/function-name.js
similarity index 99%
rename from test/mjsunit/harmony/function-name.js
rename to test/mjsunit/es6/function-name.js
index 66a69e0..152a631 100644
--- a/test/mjsunit/harmony/function-name.js
+++ b/test/mjsunit/es6/function-name.js
@@ -1,8 +1,6 @@
// 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.
-//
-// Flags: --harmony-function-name
(function testVariableDeclarationsFunction() {
'use strict';
diff --git a/test/mjsunit/es6/generators-debug-liveedit.js b/test/mjsunit/es6/generators-debug-liveedit.js
index 987a42c..2bbbfc2 100644
--- a/test/mjsunit/es6/generators-debug-liveedit.js
+++ b/test/mjsunit/es6/generators-debug-liveedit.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --expose-debug-as debug --allow-natives-syntax
+// Flags: --expose-debug-as debug --allow-natives-syntax --ignition-generators
var Debug = debug.Debug;
var LiveEdit = Debug.LiveEdit;
diff --git a/test/mjsunit/es6/generators-debug-scopes.js b/test/mjsunit/es6/generators-debug-scopes.js
index 126572d..b2a1ded 100644
--- a/test/mjsunit/es6/generators-debug-scopes.js
+++ b/test/mjsunit/es6/generators-debug-scopes.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --expose-debug-as debug
+// Flags: --expose-debug-as debug --ignition-generators
var Debug = debug.Debug;
diff --git a/test/mjsunit/es6/generators-iteration.js b/test/mjsunit/es6/generators-iteration.js
index ae4c682..8f0a774 100644
--- a/test/mjsunit/es6/generators-iteration.js
+++ b/test/mjsunit/es6/generators-iteration.js
@@ -25,7 +25,7 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --expose-gc
+// Flags: --expose-gc --ignition-generators
// Test generator iteration.
diff --git a/test/mjsunit/es6/generators-mirror.js b/test/mjsunit/es6/generators-mirror.js
index bf21f4d..62fbae0 100644
--- a/test/mjsunit/es6/generators-mirror.js
+++ b/test/mjsunit/es6/generators-mirror.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --expose-debug-as debug
+// Flags: --expose-debug-as debug --ignition-generators
// Test the mirror object for functions.
function *generator(f) {
diff --git a/test/mjsunit/es6/generators-objects.js b/test/mjsunit/es6/generators-objects.js
index 2d23841..9a07518 100644
--- a/test/mjsunit/es6/generators-objects.js
+++ b/test/mjsunit/es6/generators-objects.js
@@ -25,7 +25,7 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --allow-natives-syntax
+// Flags: --allow-natives-syntax --ignition-generators
// Test instantations of generators.
@@ -113,3 +113,17 @@
assertSame(generator_prototype, Object.getPrototypeOf(g()));
}
TestPrototype();
+
+
+function TestComputedPropertyNames() {
+ function* f1() { return {[yield]: 42} }
+ var g1 = f1();
+ g1.next();
+ assertEquals(42, g1.next('a').value.a);
+
+ function* f2() { return {['a']: yield} }
+ var g2 = f2();
+ g2.next();
+ assertEquals(42, g2.next(42).value.a);
+}
+TestComputedPropertyNames();
diff --git a/test/mjsunit/es6/generators-parsing.js b/test/mjsunit/es6/generators-parsing.js
index f3f8cad..143c3d7 100644
--- a/test/mjsunit/es6/generators-parsing.js
+++ b/test/mjsunit/es6/generators-parsing.js
@@ -25,6 +25,8 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Flags: --ignition-generators
+
// Test basic generator syntax.
// Yield statements.
diff --git a/test/mjsunit/es6/generators-poisoned-properties.js b/test/mjsunit/es6/generators-poisoned-properties.js
index e861022..5a0c652 100644
--- a/test/mjsunit/es6/generators-poisoned-properties.js
+++ b/test/mjsunit/es6/generators-poisoned-properties.js
@@ -2,6 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+// Flags: --ignition-generators
+
(function testRestrictedPropertiesStrict() {
function* generator() { "use strict"; }
assertFalse(generator.hasOwnProperty("arguments"));
diff --git a/test/mjsunit/es6/generators-relocation.js b/test/mjsunit/es6/generators-relocation.js
index 2636f52..28311a8 100644
--- a/test/mjsunit/es6/generators-relocation.js
+++ b/test/mjsunit/es6/generators-relocation.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --expose-debug-as debug
+// Flags: --expose-debug-as debug --ignition-generators
var Debug = debug.Debug;
diff --git a/test/mjsunit/es6/generators-runtime.js b/test/mjsunit/es6/generators-runtime.js
index 5c426b2..0cdbfca 100644
--- a/test/mjsunit/es6/generators-runtime.js
+++ b/test/mjsunit/es6/generators-runtime.js
@@ -25,6 +25,8 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Flags: --ignition-generators
+
// Test aspects of the generator runtime.
// See:
diff --git a/test/mjsunit/es6/generators-states.js b/test/mjsunit/es6/generators-states.js
index 4e8c580..fb6b14a 100644
--- a/test/mjsunit/es6/generators-states.js
+++ b/test/mjsunit/es6/generators-states.js
@@ -2,6 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+// Flags: --ignition-generators
+
// Test generator states.
function Foo() {}
diff --git a/test/mjsunit/harmony/instanceof-es6.js b/test/mjsunit/es6/instanceof.js
similarity index 97%
rename from test/mjsunit/harmony/instanceof-es6.js
rename to test/mjsunit/es6/instanceof.js
index 4971c9c..6bf2259 100644
--- a/test/mjsunit/harmony/instanceof-es6.js
+++ b/test/mjsunit/es6/instanceof.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-instanceof
-
// Make sure it's an error if @@hasInstance isn't a function.
(function() {
var F = {};
diff --git a/test/mjsunit/harmony/iterator-close.js b/test/mjsunit/es6/iterator-close.js
similarity index 99%
rename from test/mjsunit/harmony/iterator-close.js
rename to test/mjsunit/es6/iterator-close.js
index 03cdeac..1a96bee 100644
--- a/test/mjsunit/harmony/iterator-close.js
+++ b/test/mjsunit/es6/iterator-close.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-iterator-close
-
function* g() { yield 42; return 88 };
diff --git a/test/mjsunit/es6/json.js b/test/mjsunit/es6/json.js
index 4c1ada8..c049a25 100644
--- a/test/mjsunit/es6/json.js
+++ b/test/mjsunit/es6/json.js
@@ -9,5 +9,7 @@
assertTrue(desc.configurable);
assertFalse(desc.writable);
assertEquals("JSON", desc.value);
+ delete JSON[Symbol.toStringTag];
+ assertEquals('[object Object]', "" + JSON);
}
testJSONToString();
diff --git a/test/mjsunit/es6/legacy-subclassing.js b/test/mjsunit/es6/legacy-subclassing.js
deleted file mode 100644
index dbf666d..0000000
--- a/test/mjsunit/es6/legacy-subclassing.js
+++ /dev/null
@@ -1,38 +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.
-
-// Flags: --noharmony-species
-
-// Before Symbol.species was added, ArrayBuffer subclasses constructed
-// ArrayBuffers, and Array subclasses constructed Arrays, but TypedArray and
-// Promise subclasses constructed an instance of the subclass.
-
-'use strict';
-
-assertEquals(undefined, Symbol.species);
-
-class MyArray extends Array { }
-let myArray = new MyArray();
-assertEquals(MyArray, myArray.constructor);
-assertEquals(Array, myArray.map(x => x + 1).constructor);
-assertEquals(Array, myArray.concat().constructor);
-
-class MyUint8Array extends Uint8Array { }
-Object.defineProperty(MyUint8Array.prototype, "BYTES_PER_ELEMENT", {value: 1});
-let myTypedArray = new MyUint8Array(3);
-assertEquals(MyUint8Array, myTypedArray.constructor);
-assertEquals(MyUint8Array, myTypedArray.map(x => x + 1).constructor);
-
-class MyArrayBuffer extends ArrayBuffer { }
-let myBuffer = new MyArrayBuffer(0);
-assertEquals(MyArrayBuffer, myBuffer.constructor);
-assertEquals(ArrayBuffer, myBuffer.slice().constructor);
-
-class MyPromise extends Promise { }
-let myPromise = new MyPromise(() => {});
-assertEquals(MyPromise, myPromise.constructor);
-assertEquals(MyPromise, myPromise.then().constructor);
-
-// However, subarray instantiates members of the parent class
-assertEquals(Uint8Array, myTypedArray.subarray(1).constructor);
diff --git a/test/mjsunit/es6/math-log2-log10.js b/test/mjsunit/es6/math-log2-log10.js
index b1a7736..ea17a79 100644
--- a/test/mjsunit/es6/math-log2-log10.js
+++ b/test/mjsunit/es6/math-log2-log10.js
@@ -57,13 +57,13 @@
var n = -1074;
// This loop covers n from -1074 to -1043
for (var lowbits = 1; lowbits <= 0x80000000; lowbits *= 2) {
- var x = %_ConstructDouble(0, lowbits);
+ var x = %ConstructDouble(0, lowbits);
assertEquals(n, Math.log2(x));
n++;
}
// This loop covers n from -1042 to -1023
for (var hibits = 1; hibits <= 0x80000; hibits *= 2) {
- var x = %_ConstructDouble(hibits, 0);
+ var x = %ConstructDouble(hibits, 0);
assertEquals(n, Math.log2(x));
n++;
}
diff --git a/test/mjsunit/es6/math.js b/test/mjsunit/es6/math.js
index cb43bd5..dc761d6 100644
--- a/test/mjsunit/es6/math.js
+++ b/test/mjsunit/es6/math.js
@@ -9,5 +9,7 @@
assertTrue(desc.configurable);
assertFalse(desc.writable);
assertEquals("Math", desc.value);
+ delete Math[Symbol.toStringTag];
+ assertEquals('[object Object]', "" + Math);
}
testMathToString();
diff --git a/test/mjsunit/es6/no-unicode-regexp-flag.js b/test/mjsunit/es6/no-unicode-regexp-flag.js
deleted file mode 100644
index 82d070e..0000000
--- a/test/mjsunit/es6/no-unicode-regexp-flag.js
+++ /dev/null
@@ -1,24 +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.
-
-// Before Unicode RegExps are shipped, we shouldn't have the 'unicode'
-// property on RegExp.prototype, or read it from 'flags'.
-// mjsunit/es6/regexp-flags tests that the property is there when the
-// flag is on.
-
-// Flags: --no-harmony-unicode-regexps
-
-'use strict';
-
-assertFalse(RegExp.prototype.hasOwnProperty('unicode'));
-
-// If we were going to be really strict, we could have a test like this,
-// with the assertTrue replaced by assertFalse, since flags shouldn't
-// Get the 'unicode' property. However, it is probably OK to omit this
-// detailed fix.
-var x = /a/;
-var y = false;
-Object.defineProperty(x, 'unicode', { get() { y = true; } });
-assertEquals("", x.flags);
-assertTrue(y);
diff --git a/test/mjsunit/es6/object-tostring.js b/test/mjsunit/es6/object-tostring.js
index 29d07f2..bc7d968 100644
--- a/test/mjsunit/es6/object-tostring.js
+++ b/test/mjsunit/es6/object-tostring.js
@@ -15,15 +15,16 @@
RegExp: [ RegExp ],
Error: [ Error, TypeError, RangeError, SyntaxError, ReferenceError,
EvalError, URIError ]
-}
-for (f in funs) {
- for (i in funs[f]) {
+};
+for (var f in funs) {
+ for (var i in funs[f]) {
+
assertEquals("[object " + f + "]",
- Object.prototype.toString.call(new funs[f][i]),
- funs[f][i]);
+ Object.prototype.toString.call(new funs[f][i]),
+ funs[f][i]);
assertEquals("[object Function]",
- Object.prototype.toString.call(funs[f][i]),
- funs[f][i]);
+ Object.prototype.toString.call(funs[f][i]),
+ funs[f][i]);
}
}
@@ -130,11 +131,11 @@
}
testObjectToStringPropertyDesc();
-function testObjectToStringOwnNonStringValue() {
- var obj = Object.defineProperty({}, Symbol.toStringTag, { value: 1 });
+function testObjectToStringOnNonStringValue(obj) {
+ Object.defineProperty(obj, Symbol.toStringTag, { value: 1 });
assertEquals("[object Object]", ({}).toString.call(obj));
}
-testObjectToStringOwnNonStringValue();
+testObjectToStringOnNonStringValue({});
// Proxies
@@ -149,11 +150,77 @@
assertTag("Foo", new Proxy(() => 42, {get() {return "Foo"}}));
assertTag("Function", new Proxy(() => 42, {get() {return 666}}));
-revocable = Proxy.revocable([], {});
+var revocable = Proxy.revocable([], {});
revocable.revoke();
assertThrows(() => Object.prototype.toString.call(revocable.proxy), TypeError);
-handler = {};
+var handler = {};
revocable = Proxy.revocable([], handler);
+// The first get() call, i.e., toString() revokes the proxy
handler.get = () => revocable.revoke();
+assertEquals("[object Array]", Object.prototype.toString.call(revocable.proxy));
assertThrows(() => Object.prototype.toString.call(revocable.proxy), TypeError);
+
+revocable = Proxy.revocable([], handler);
+handler.get = () => {revocable.revoke(); return "value";};
+assertEquals("[object value]", Object.prototype.toString.call(revocable.proxy));
+assertThrows(() => Object.prototype.toString.call(revocable.proxy), TypeError);
+
+
+revocable = Proxy.revocable(function() {}, handler);
+handler.get = () => revocable.revoke();
+assertEquals("[object Function]", Object.prototype.toString.call(revocable.proxy));
+assertThrows(() => Object.prototype.toString.call(revocable.proxy), TypeError);
+
+function* gen() { yield 1; }
+
+assertTag("GeneratorFunction", gen);
+Object.defineProperty(gen, Symbol.toStringTag, {writable: true});
+gen[Symbol.toStringTag] = "different string";
+assertTag("different string", gen);
+gen[Symbol.toStringTag] = 1;
+assertTag("Function", gen);
+
+function overwriteToStringTagWithNonStringValue(tag, obj) {
+ assertTag(tag, obj);
+
+ Object.defineProperty(obj, Symbol.toStringTag, {
+ configurable: true,
+ value: "different string"
+ });
+ assertTag("different string", obj);
+
+ testObjectToStringOnNonStringValue(obj);
+}
+
+overwriteToStringTagWithNonStringValue("global", global);
+overwriteToStringTagWithNonStringValue("Generator", gen());
+
+var arrayBuffer = new ArrayBuffer();
+overwriteToStringTagWithNonStringValue("ArrayBuffer", arrayBuffer);
+overwriteToStringTagWithNonStringValue("DataView", new DataView(arrayBuffer));
+
+overwriteToStringTagWithNonStringValue("Int8Array", new Int8Array());
+overwriteToStringTagWithNonStringValue("Uint8Array", new Uint8Array());
+overwriteToStringTagWithNonStringValue("Uint8ClampedArray",
+ new Uint8ClampedArray());
+overwriteToStringTagWithNonStringValue("Int16Array", new Int16Array());
+overwriteToStringTagWithNonStringValue("Uint16Array", new Uint16Array());
+overwriteToStringTagWithNonStringValue("Int32Array", new Int32Array());
+overwriteToStringTagWithNonStringValue("Uint32Array", new Uint32Array());
+overwriteToStringTagWithNonStringValue("Float32Array", new Float32Array());
+overwriteToStringTagWithNonStringValue("Float64Array", new Float64Array());
+
+var set = new Set();
+var map = new Map();
+
+overwriteToStringTagWithNonStringValue("Set", set);
+overwriteToStringTagWithNonStringValue("Map", map);
+
+overwriteToStringTagWithNonStringValue("Set Iterator", set[Symbol.iterator]());
+overwriteToStringTagWithNonStringValue("Map Iterator", map[Symbol.iterator]());
+
+overwriteToStringTagWithNonStringValue("WeakSet", new WeakSet());
+overwriteToStringTagWithNonStringValue("WeakMap", new WeakMap());
+
+overwriteToStringTagWithNonStringValue("Promise", new Promise(function() {}));
diff --git a/test/mjsunit/es6/pattern-brand-check.js b/test/mjsunit/es6/pattern-brand-check.js
index 9b0c011..2e32294 100644
--- a/test/mjsunit/es6/pattern-brand-check.js
+++ b/test/mjsunit/es6/pattern-brand-check.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-subclass
-
function createNonRegExp(calls) {
return {
get [Symbol.match]() {
diff --git a/test/mjsunit/harmony/promise-species.js b/test/mjsunit/es6/promise-species.js
similarity index 95%
rename from test/mjsunit/harmony/promise-species.js
rename to test/mjsunit/es6/promise-species.js
index 12244f2..f6f2e7a 100644
--- a/test/mjsunit/harmony/promise-species.js
+++ b/test/mjsunit/es6/promise-species.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species --allow-natives-syntax
+// Flags: --allow-natives-syntax
// Test that Promises use @@species appropriately
diff --git a/test/mjsunit/es6/proxies-for.js b/test/mjsunit/es6/proxies-for.js
index a171227..2b3060b 100644
--- a/test/mjsunit/es6/proxies-for.js
+++ b/test/mjsunit/es6/proxies-for.js
@@ -151,7 +151,7 @@
object.__proto__ = proxy;
assertEquals(["0"], keys(object));
- // The Proxy doesn't set his ownKeys enumerable.
+ // The Proxy doesn't set its ownKeys enumerable.
delete object[0];
assertEquals([], keys(object));
diff --git a/test/mjsunit/es6/proxies-json.js b/test/mjsunit/es6/proxies-json.js
index d48d539..6b40e3e 100644
--- a/test/mjsunit/es6/proxies-json.js
+++ b/test/mjsunit/es6/proxies-json.js
@@ -35,7 +35,10 @@
// Test fast case that bails out to slow case.
assertEquals(expected, JSON.stringify(object));
// Test slow case.
- assertEquals(expected, JSON.stringify(object, undefined, 0));
+ assertEquals(expected, JSON.stringify(object, (key, value) => value));
+ // Test gap.
+ assertEquals(JSON.stringify(object, null, "="),
+ JSON.stringify(object, (key, value) => value, "="));
}
@@ -67,6 +70,7 @@
var parent1a = { b: proxy1 };
testStringify('{"b":{"a":"A","b":"B","c":"C"}}', parent1a);
+testStringify('{"b":{"a":"A","b":"B","c":"C"}}', parent1a);
var parent1b = { a: 123, b: proxy1, c: true };
testStringify('{"a":123,"b":{"a":"A","b":"B","c":"C"},"c":true}', parent1b);
@@ -503,3 +507,56 @@
assertEquals(["get", target, "length", proxy], log[0]);
assertEquals(["get", target, "0", proxy], log[1]);
assertEquals(["deleteProperty", target, "0"], log[2]);
+
+proxy = new Proxy([], {
+ get: function(target, property) {
+ if (property == "length") return 7;
+ return 0;
+ },
+});
+assertEquals('[[0,0,0,0,0,0,0]]', JSON.stringify([proxy]));
+
+proxy = new Proxy([], {
+ get: function(target, property) {
+ if (property == "length") return 1E40;
+ return 0;
+ },
+});
+assertThrows(() => JSON.stringify([proxy]), RangeError);
+
+log = [];
+proxy = new Proxy({}, {
+ ownKeys: function() {
+ log.push("ownKeys");
+ return ["0", "a", "b"];
+ },
+ get: function(target, property) {
+ log.push("get " + property);
+ return property.toUpperCase();
+ },
+ getOwnPropertyDescriptor: function(target, property) {
+ log.push("descriptor " + property);
+ return {enumerable: true, configurable: true};
+ },
+ isExtensible: assertUnreachable,
+ has: assertUnreachable,
+ getPrototypeOf: assertUnreachable,
+ setPrototypeOf: assertUnreachable,
+ preventExtensions: assertUnreachable,
+ setPrototypeOf: assertUnreachable,
+ defineProperty: assertUnreachable,
+ set: assertUnreachable,
+ deleteProperty: assertUnreachable,
+ apply: assertUnreachable,
+ construct: assertUnreachable,
+});
+
+assertEquals('[{"0":"0","a":"A","b":"B"}]', JSON.stringify([proxy]));
+assertEquals(['get toJSON',
+ 'ownKeys',
+ 'descriptor 0',
+ 'descriptor a',
+ 'descriptor b',
+ 'get 0',
+ 'get a',
+ 'get b'], log);
diff --git a/test/mjsunit/es6/proxies-keys.js b/test/mjsunit/es6/proxies-keys.js
index 65dea6a..2635ac3 100644
--- a/test/mjsunit/es6/proxies-keys.js
+++ b/test/mjsunit/es6/proxies-keys.js
@@ -48,3 +48,31 @@
assertEquals(["1","2"], Object.getOwnPropertyNames(p));
assertEquals([symbol], Object.getOwnPropertySymbols(p));
})();
+
+(function testNoProxyTraps() {
+ var test_sym = Symbol("sym1");
+ var test_sym2 = Symbol("sym2");
+ var target = {
+ one: 1,
+ two: 2,
+ [test_sym]: 4,
+ 0: 0,
+ };
+ Object.defineProperty(
+ target, "non-enum",
+ { enumerable: false, value: "nope", configurable: true, writable: true });
+ target.__proto__ = {
+ target_proto: 3,
+ 1: 1,
+ [test_sym2]: 5
+ };
+ Object.defineProperty(
+ target.__proto__, "non-enum2",
+ { enumerable: false, value: "nope", configurable: true, writable: true });
+ var proxy = new Proxy(target, {});
+
+ assertEquals(["0", "one", "two"], Object.keys(proxy));
+ assertEquals(["0", "one", "two", "non-enum"],
+ Object.getOwnPropertyNames(proxy));
+ assertEquals([test_sym], Object.getOwnPropertySymbols(proxy));
+})();
diff --git a/test/mjsunit/es6/reflect.js b/test/mjsunit/es6/reflect.js
index ee272b0..d597a78 100644
--- a/test/mjsunit/es6/reflect.js
+++ b/test/mjsunit/es6/reflect.js
@@ -541,6 +541,13 @@
[s2]: 0, "-1": 0, "88": 0, "aaa": 0 };
assertEquals(["0", "42", "88", "bla", "-1", "aaa", s1, s2],
Reflect.ownKeys(obj));
+ // Force dict-mode elements.
+ delete obj[0];
+ assertEquals(["42", "88", "bla", "-1", "aaa", s1, s2],
+ Reflect.ownKeys(obj));
+ // Force dict-mode properties.
+ delete obj["bla"];
+ assertEquals(["42", "88", "-1", "aaa", s1, s2], Reflect.ownKeys(obj));
})();
diff --git a/test/mjsunit/es6/regexp-constructor.js b/test/mjsunit/es6/regexp-constructor.js
index 559ac00..b685ff2 100644
--- a/test/mjsunit/es6/regexp-constructor.js
+++ b/test/mjsunit/es6/regexp-constructor.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-subclass
-
"use strict";
function should_not_be_called() {
diff --git a/test/mjsunit/es6/regexp-flags.js b/test/mjsunit/es6/regexp-flags.js
index 480222d..2bcccfa 100644
--- a/test/mjsunit/es6/regexp-flags.js
+++ b/test/mjsunit/es6/regexp-flags.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps
-
var r1 = /abc/gi;
assertEquals("abc", r1.source);
assertTrue(r1.global);
diff --git a/test/mjsunit/harmony/species.js b/test/mjsunit/es6/species.js
similarity index 97%
rename from test/mjsunit/harmony/species.js
rename to test/mjsunit/es6/species.js
index da1df43..39156a4 100644
--- a/test/mjsunit/harmony/species.js
+++ b/test/mjsunit/es6/species.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species
-
// Test the ES2015 @@species feature
'use strict';
diff --git a/test/mjsunit/harmony/string-match.js b/test/mjsunit/es6/string-match.js
similarity index 94%
rename from test/mjsunit/harmony/string-match.js
rename to test/mjsunit/es6/string-match.js
index 25a3ca2..2c7affe 100644
--- a/test/mjsunit/harmony/string-match.js
+++ b/test/mjsunit/es6/string-match.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-subclass
-
var pattern = {};
pattern[Symbol.match] = function(string) {
return string.length;
diff --git a/test/mjsunit/harmony/string-replace.js b/test/mjsunit/es6/string-replace.js
similarity index 94%
rename from test/mjsunit/harmony/string-replace.js
rename to test/mjsunit/es6/string-replace.js
index 208c483..0beb57a 100644
--- a/test/mjsunit/harmony/string-replace.js
+++ b/test/mjsunit/es6/string-replace.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-subclass
-
var pattern = {
[Symbol.replace]: (string, newValue) => string + newValue
};
diff --git a/test/mjsunit/es6/string-search.js b/test/mjsunit/es6/string-search.js
index dc02982..cbdf33d 100644
--- a/test/mjsunit/es6/string-search.js
+++ b/test/mjsunit/es6/string-search.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-subclass
-
var pattern = {};
pattern[Symbol.search] = function(string) {
return string.length;
diff --git a/test/mjsunit/harmony/string-split.js b/test/mjsunit/es6/string-split.js
similarity index 94%
rename from test/mjsunit/harmony/string-split.js
rename to test/mjsunit/es6/string-split.js
index 1240d84..8ca655c 100644
--- a/test/mjsunit/harmony/string-split.js
+++ b/test/mjsunit/es6/string-split.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-subclass
-
var pattern = {};
var limit = { value: 3 };
pattern[Symbol.split] = function(string, limit) {
diff --git a/test/mjsunit/es6/symbols.js b/test/mjsunit/es6/symbols.js
index 9bac41f..a21afb3 100644
--- a/test/mjsunit/es6/symbols.js
+++ b/test/mjsunit/es6/symbols.js
@@ -555,7 +555,9 @@
function TestStringify(expected, input) {
assertEquals(expected, JSON.stringify(input));
- assertEquals(expected, JSON.stringify(input, null, 0));
+ assertEquals(expected, JSON.stringify(input, (key, value) => value));
+ assertEquals(JSON.stringify(input, null, "="),
+ JSON.stringify(input, (key, value) => value, "="));
}
TestStringify(undefined, Symbol("a"));
diff --git a/test/mjsunit/es6/tail-call-megatest.js b/test/mjsunit/es6/tail-call-megatest.js
index 1de8ec6..3d2ecb8 100644
--- a/test/mjsunit/es6/tail-call-megatest.js
+++ b/test/mjsunit/es6/tail-call-megatest.js
@@ -10,6 +10,7 @@
return error.message + "\n at " + stack.join("\n at ");
}
+var verbose = typeof(arguments) !== "undefined" && arguments.indexOf("-v") >= 0;
function checkStackTrace(expected) {
var e = new Error();
@@ -340,32 +341,32 @@
return source;
}
- var f_args_variants = ["", "1", "1, 2"];
- var g_args_variants = ["", "10", "10, 20"];
+ var f_args_variants = [/*"", "1",*/ "1, 2"];
+ var g_args_variants = [/*"", "10",*/ "10, 20"];
var f_inlinable_variants = [true, false];
var g_inlinable_variants = [true, false];
// This is to avoid bailing out because of referencing new.target.
- var check_new_target_variants = [true, false];
+ var check_new_target_variants = [/*true,*/ false];
var deopt_mode_variants = ["none", "f", "g", "test"];
var f_variants = [
f_cfg_sloppy,
f_cfg_strict,
f_cfg_bound,
f_cfg_proxy,
- f_cfg_possibly_eval,
+// f_cfg_possibly_eval,
];
var g_variants = [
g_cfg_normal,
- g_cfg_reflect_apply,
+// g_cfg_reflect_apply,
g_cfg_function_apply,
- g_cfg_function_apply_arguments_object,
+// g_cfg_function_apply_arguments_object,
g_cfg_function_call,
];
var test_warmup_counts = [0, 1, 2];
var iter = 0;
var tests_executed = 0;
- if (shard !== undefined) {
+ if (verbose && shard !== undefined) {
print("Running shard #" + shard);
}
f_variants.forEach((f_cfg) => {
@@ -378,7 +379,9 @@
g_inlinable_variants.forEach((g_inlinable) => {
test_warmup_counts.forEach((test_warmup_count) => {
if (shard !== undefined && (iter++) % SHARDS_COUNT != shard) {
- print("skipping...");
+ if (verbose) {
+ print("skipping...");
+ }
return;
}
tests_executed++;
@@ -396,8 +399,10 @@
deopt_mode,
};
var source = test_template(cfg);
- print("====================");
- print(source);
+ if (verbose) {
+ // print("====================");
+ // print(source);
+ }
eval(source);
});
});
@@ -408,7 +413,9 @@
});
});
});
- print("Number of tests executed: " + tests_executed);
+ if (verbose) {
+ print("Number of tests executed: " + tests_executed);
+ }
}
// Uncomment to run all the tests at once or use shard runners.
diff --git a/test/mjsunit/es6/typedarray-set-length-internal.js b/test/mjsunit/es6/typedarray-set-length-internal.js
new file mode 100644
index 0000000..22b8f67
--- /dev/null
+++ b/test/mjsunit/es6/typedarray-set-length-internal.js
@@ -0,0 +1,35 @@
+// 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.
+
+var typedArrayConstructors = [
+ Uint8Array,
+ Int8Array,
+ Uint16Array,
+ Int16Array,
+ Uint32Array,
+ Int32Array,
+ Uint8ClampedArray,
+ Float32Array,
+ Float64Array
+];
+
+var descriptor = { get: function() { throw new Error("accessed length"); } };
+
+for (var constructor of typedArrayConstructors) {
+ var differentConstructor =
+ constructor === Uint8Array ? Int8Array : Uint8Array;
+ var target = new constructor(16);
+ Object.defineProperty(target, "length", descriptor);
+
+ var sameBuffer = new differentConstructor(target.buffer, 0, 2);
+ Object.defineProperty(sameBuffer, "length", descriptor);
+ target.set(sameBuffer);
+
+ var differentBuffer = new differentConstructor(16);
+ Object.defineProperty(differentBuffer, "length", descriptor);
+ target.set(differentBuffer);
+
+ var array = [0, 1, 2];
+ target.set(array);
+}
diff --git a/test/mjsunit/harmony/typedarray-species.js b/test/mjsunit/es6/typedarray-species.js
similarity index 98%
rename from test/mjsunit/harmony/typedarray-species.js
rename to test/mjsunit/es6/typedarray-species.js
index 35a9ea1..020d65c 100644
--- a/test/mjsunit/harmony/typedarray-species.js
+++ b/test/mjsunit/es6/typedarray-species.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species
-
// Subclasses of %TypedArray% construct themselves under map, etc
var typedArrayConstructors = [
diff --git a/test/mjsunit/harmony/unicode-character-ranges.js b/test/mjsunit/es6/unicode-character-ranges.js
similarity index 98%
rename from test/mjsunit/harmony/unicode-character-ranges.js
rename to test/mjsunit/es6/unicode-character-ranges.js
index e4f5247..f39004f 100644
--- a/test/mjsunit/harmony/unicode-character-ranges.js
+++ b/test/mjsunit/es6/unicode-character-ranges.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps --harmony-regexp-lookbehind
+// Flags: --harmony-regexp-lookbehind
function execl(expectation, regexp, subject) {
if (regexp instanceof String) regexp = new RegExp(regexp, "u");
diff --git a/test/mjsunit/harmony/unicode-escapes-in-regexps.js b/test/mjsunit/es6/unicode-escapes-in-regexps.js
similarity index 99%
rename from test/mjsunit/harmony/unicode-escapes-in-regexps.js
rename to test/mjsunit/es6/unicode-escapes-in-regexps.js
index 7ea6f62..2d2d118 100644
--- a/test/mjsunit/harmony/unicode-escapes-in-regexps.js
+++ b/test/mjsunit/es6/unicode-escapes-in-regexps.js
@@ -4,8 +4,6 @@
// ES6 extends the \uxxxx escape and also allows \u{xxxxx}.
-// Flags: --harmony-unicode-regexps
-
function testRegexpHelper(r) {
assertTrue(r.test("foo"));
assertTrue(r.test("boo"));
diff --git a/test/mjsunit/harmony/unicode-regexp-backrefs.js b/test/mjsunit/es6/unicode-regexp-backrefs.js
similarity index 96%
rename from test/mjsunit/harmony/unicode-regexp-backrefs.js
rename to test/mjsunit/es6/unicode-regexp-backrefs.js
index e02301b..56b9c5e 100644
--- a/test/mjsunit/harmony/unicode-regexp-backrefs.js
+++ b/test/mjsunit/es6/unicode-regexp-backrefs.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps --harmony-regexp-lookbehind
+// Flags: --harmony-regexp-lookbehind
// Back reference does not end in the middle of a surrogate pair.
function replace(string) {
diff --git a/test/mjsunit/harmony/unicode-regexp-ignore-case-noi18n.js b/test/mjsunit/es6/unicode-regexp-ignore-case-noi18n.js
similarity index 97%
rename from test/mjsunit/harmony/unicode-regexp-ignore-case-noi18n.js
rename to test/mjsunit/es6/unicode-regexp-ignore-case-noi18n.js
index a4cb9dc..a998942 100644
--- a/test/mjsunit/harmony/unicode-regexp-ignore-case-noi18n.js
+++ b/test/mjsunit/es6/unicode-regexp-ignore-case-noi18n.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps
-
// Non-unicode use toUpperCase mappings.
assertFalse(/[\u00e5]/i.test("\u212b"));
assertFalse(/[\u212b]/i.test("\u00e5\u1234"));
diff --git a/test/mjsunit/harmony/unicode-regexp-ignore-case.js b/test/mjsunit/es6/unicode-regexp-ignore-case.js
similarity index 98%
rename from test/mjsunit/harmony/unicode-regexp-ignore-case.js
rename to test/mjsunit/es6/unicode-regexp-ignore-case.js
index 291b866..dd02ca9 100644
--- a/test/mjsunit/harmony/unicode-regexp-ignore-case.js
+++ b/test/mjsunit/es6/unicode-regexp-ignore-case.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps
-
// Non-unicode use toUpperCase mappings.
assertFalse(/[\u00e5]/i.test("\u212b"));
assertFalse(/[\u212b]/i.test("\u00e5\u1234"));
diff --git a/test/mjsunit/harmony/unicode-regexp-last-index.js b/test/mjsunit/es6/unicode-regexp-last-index.js
similarity index 97%
rename from test/mjsunit/harmony/unicode-regexp-last-index.js
rename to test/mjsunit/es6/unicode-regexp-last-index.js
index 4a075d4..67fbac7 100644
--- a/test/mjsunit/harmony/unicode-regexp-last-index.js
+++ b/test/mjsunit/es6/unicode-regexp-last-index.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps --harmony-regexp-lookbehind
+// Flags: --harmony-regexp-lookbehind
var r = /./ug;
assertEquals(["\ud800\udc00"], r.exec("\ud800\udc00\ud801\udc01"));
diff --git a/test/mjsunit/harmony/unicode-regexp-restricted-syntax.js b/test/mjsunit/es6/unicode-regexp-restricted-syntax.js
similarity index 97%
rename from test/mjsunit/harmony/unicode-regexp-restricted-syntax.js
rename to test/mjsunit/es6/unicode-regexp-restricted-syntax.js
index d129cc3..dd4fa39 100644
--- a/test/mjsunit/harmony/unicode-regexp-restricted-syntax.js
+++ b/test/mjsunit/es6/unicode-regexp-restricted-syntax.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps
-
// test262/data/test/language/literals/regexp/u-dec-esc
assertThrows("/\\1/u", SyntaxError);
// test262/language/literals/regexp/u-invalid-char-range-a
diff --git a/test/mjsunit/harmony/unicode-regexp-unanchored-advance.js b/test/mjsunit/es6/unicode-regexp-unanchored-advance.js
similarity index 87%
rename from test/mjsunit/harmony/unicode-regexp-unanchored-advance.js
rename to test/mjsunit/es6/unicode-regexp-unanchored-advance.js
index 97960e1..c471122 100644
--- a/test/mjsunit/harmony/unicode-regexp-unanchored-advance.js
+++ b/test/mjsunit/es6/unicode-regexp-unanchored-advance.js
@@ -2,7 +2,5 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps
-
var s = "a".repeat(1E7) + "\u1234";
assertEquals(["\u1234", "\u1234"], /(\u1234)/u.exec(s));
diff --git a/test/mjsunit/harmony/unicode-regexp-zero-length.js b/test/mjsunit/es6/unicode-regexp-zero-length.js
similarity index 97%
rename from test/mjsunit/harmony/unicode-regexp-zero-length.js
rename to test/mjsunit/es6/unicode-regexp-zero-length.js
index bbc17dc..42bb2d7 100644
--- a/test/mjsunit/harmony/unicode-regexp-zero-length.js
+++ b/test/mjsunit/es6/unicode-regexp-zero-length.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps
-
var L = "\ud800";
var T = "\udc00";
var x = "x";
diff --git a/test/mjsunit/es7/array-includes.js b/test/mjsunit/es7/array-includes.js
index 303042a..3981797 100644
--- a/test/mjsunit/es7/array-includes.js
+++ b/test/mjsunit/es7/array-includes.js
@@ -673,3 +673,8 @@
assertFalse(Array.prototype.includes.call(new Uint8Array([1, 2, 3]), 4));
assertFalse(Array.prototype.includes.call(new Uint8Array([1, 2, 3]), 2, 2));
})();
+
+
+(function testUnscopable() {
+ assertTrue(Array.prototype[Symbol.unscopables].includes);
+})();
diff --git a/test/mjsunit/es8/syntactic-tail-call-parsing.js b/test/mjsunit/es8/syntactic-tail-call-parsing.js
index 9ceff9c..486c3e1 100644
--- a/test/mjsunit/es8/syntactic-tail-call-parsing.js
+++ b/test/mjsunit/es8/syntactic-tail-call-parsing.js
@@ -3,7 +3,7 @@
// found in the LICENSE file.
// Flags: --allow-natives-syntax --harmony-explicit-tailcalls
-// Flags: --harmony-do-expressions
+// Flags: --harmony-do-expressions --harmony-async-await
"use strict";
var SyntaxErrorTests = [
@@ -128,7 +128,10 @@
err: ` ^^^^^^^^^^^^^^`,
},
{ src: `()=>{ function* G() { yield continue foo(); } }`,
- err: ` ^^^^^^^^^^^^^^`,
+ err: ` ^^^^^`,
+ },
+ { src: `()=>{ function* G() { return continue foo(); } }`,
+ err: ` ^^^^^`,
},
{ src: `()=>{ (1, 2, 3, continue f() ) => {} }`,
err: ` ^^^^^^^^^^^^`,
@@ -235,6 +238,9 @@
{ src: `class A extends continue f () {}; }`,
err: ` ^^^^^^^^^^^^^`,
},
+ { src: `async() => continue foo()`,
+ err: ` ^^^^^`,
+ },
],
},
{ msg: "Tail call expression in try block",
@@ -311,7 +317,6 @@
`()=>{ return a || continue f() ; }`,
`()=>{ return a && continue f() ; }`,
`()=>{ return a , continue f() ; }`,
- `()=>{ function* G() { return continue foo(); } }`,
`()=>{ class A { foo() { return continue super.f() ; } } }`,
`()=>{ function B() { return continue new.target() ; } }`,
`()=>{ return continue do { x ? foo() : bar() ; }() }`,
diff --git a/test/mjsunit/fast-prototype.js b/test/mjsunit/fast-prototype.js
index 7432ecc..aa0a62e 100644
--- a/test/mjsunit/fast-prototype.js
+++ b/test/mjsunit/fast-prototype.js
@@ -46,14 +46,20 @@
function DoProtoMagic(proto, set__proto__) {
+ var receiver;
if (set__proto__) {
- (new Sub()).__proto__ = proto;
+ receiver = new Sub();
+ receiver.__proto__ = proto;
} else {
Sub.prototype = proto;
// Need to instantiate Sub to mark .prototype as prototype. Make sure the
// instantiated object is used so that the allocation is not optimized away.
- %DebugPrint(new Sub());
+ receiver = new Sub();
}
+ // Prototypes are made fast when ICs encounter them.
+ function ic() { return typeof receiver.foo; }
+ ic();
+ ic();
}
diff --git a/test/mjsunit/harmony/async-await-basic.js b/test/mjsunit/harmony/async-await-basic.js
index d0888ea..ba0350f 100644
--- a/test/mjsunit/harmony/async-await-basic.js
+++ b/test/mjsunit/harmony/async-await-basic.js
@@ -343,5 +343,27 @@
assertEquals("async x => x", (async x => x).toString());
assertEquals("async x => { return x }", (async x => { return x }).toString());
class AsyncMethod { async foo() { } }
-assertEquals("async foo() { }", Function.prototype.toString.call(AsyncMethod.prototype.foo));
-assertEquals("async foo() { }", Function.prototype.toString.call({async foo() { }}.foo));
+assertEquals("async foo() { }",
+ Function.prototype.toString.call(AsyncMethod.prototype.foo));
+assertEquals("async foo() { }",
+ Function.prototype.toString.call({async foo() { }}.foo));
+
+// Async functions are not constructible
+assertThrows(() => class extends (async function() {}) {}, TypeError);
+
+// Regress v8:5148
+assertEqualsAsync("1", () => (async({ a = NaN }) => a)({ a: "1" }));
+assertEqualsAsync(
+ "10", () => (async(foo, { a = NaN }) => foo + a)("1", { a: "0" }));
+assertEqualsAsync("2", () => (async({ a = "2" }) => a)({ a: undefined }));
+assertEqualsAsync(
+ "20", () => (async(foo, { a = "0" }) => foo + a)("2", { a: undefined }));
+assertThrows(() => eval("async({ foo = 1 })"), SyntaxError);
+assertThrows(() => eval("async(a, { foo = 1 })"), SyntaxError);
+
+// https://bugs.chromium.org/p/chromium/issues/detail?id=638019
+async function gaga() {
+ let i = 1;
+ while (i-- > 0) { await 42 }
+}
+assertDoesNotThrow(gaga);
diff --git a/test/mjsunit/harmony/async-debug-basic.js b/test/mjsunit/harmony/async-debug-basic.js
new file mode 100644
index 0000000..a490972
--- /dev/null
+++ b/test/mjsunit/harmony/async-debug-basic.js
@@ -0,0 +1,40 @@
+// 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.
+
+// Flags: --harmony-async-await --allow-natives-syntax --expose-debug-as debug
+
+// Get the Debug object exposed from the debug context global object.
+Debug = debug.Debug
+
+listenerComplete = false;
+breakPointCount = 0;
+
+async function f() {
+ await (async function() { var a = "a"; await 1; debugger; })();
+
+ var b = "b";
+
+ assertTrue(listenerDone);
+ assertFalse(exception);
+ assertEquals(1, breakpointCount);
+}
+
+function listener(event, exec_state, event_data, data) {
+ try {
+ if (event != Debug.DebugEvent.Break) return;
+
+ breakpointCount++;
+ listenerDone = true;
+ assertEquals("a", exec_state.frame(0).evaluate("a"));
+ assertEquals("b", exec_state.frame(1).evaluate("b"));
+ assertEquals("c", exec_state.frame(2).evaluate("c"));
+ } catch (e) {
+ exception = e;
+ };
+};
+
+Debug.setListener(listener);
+
+var c = "c";
+f();
diff --git a/test/mjsunit/harmony/async-debug-step-abort-at-break.js b/test/mjsunit/harmony/async-debug-step-abort-at-break.js
new file mode 100644
index 0000000..be1f805
--- /dev/null
+++ b/test/mjsunit/harmony/async-debug-step-abort-at-break.js
@@ -0,0 +1,55 @@
+// 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.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax --harmony-async-await
+
+var Debug = debug.Debug;
+var step_count = 0;
+
+function listener(event, execState, eventData, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var line = execState.frame(0).sourceLineText();
+ print(line);
+ var [match, expected_count, step] = /\/\/ B(\d) (\w+)$/.exec(line);
+ assertEquals(step_count++, parseInt(expected_count));
+ if (step != "Continue") execState.prepareStep(Debug.StepAction[step]);
+ } catch (e) {
+ print(e, e.stack);
+ quit(1);
+ }
+}
+
+Debug.setListener(listener);
+
+var late_resolve;
+
+function g() {
+ return new Promise( // B3 StepOut
+ function(res, rej) {
+ late_resolve = res;
+ }
+ );
+}
+
+async function f() {
+ var a = 1;
+ debugger; // B0 StepNext
+ a += // B1 StepNext
+ await // B4 StepNext
+ g(); // B2 StepIn
+ return a;
+}
+
+f();
+
+// Starting a new step action at an intermediate break point
+// means that we will abort the current async step.
+debugger; // B5 StepNext
+
+late_resolve(3); // B6 Continue
+
+%RunMicrotasks();
+
+assertEquals(7, step_count);
diff --git a/test/mjsunit/harmony/async-debug-step-continue-at-break.js b/test/mjsunit/harmony/async-debug-step-continue-at-break.js
new file mode 100644
index 0000000..5099b2f
--- /dev/null
+++ b/test/mjsunit/harmony/async-debug-step-continue-at-break.js
@@ -0,0 +1,55 @@
+// 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.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax --harmony-async-await
+
+var Debug = debug.Debug;
+var step_count = 0;
+
+function listener(event, execState, eventData, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var line = execState.frame(0).sourceLineText();
+ print(line);
+ var [match, expected_count, step] = /\/\/ B(\d) (\w+)$/.exec(line);
+ assertEquals(step_count++, parseInt(expected_count));
+ if (step != "Continue") execState.prepareStep(Debug.StepAction[step]);
+ } catch (e) {
+ print(e, e.stack);
+ quit(1);
+ }
+}
+
+Debug.setListener(listener);
+
+var late_resolve;
+
+function g() {
+ return new Promise( // B3 StepOut
+ function(res, rej) {
+ late_resolve = res;
+ }
+ );
+}
+
+async function f() {
+ var a = 1;
+ debugger; // B0 StepNext
+ a += // B1 StepNext
+ await // B4 StepNext
+ g(); // B2 StepIn
+ return a; // B6 StepNext
+} // B7 Continue
+
+f();
+
+// Continuing at an intermediate break point means that we will
+// carry on with the current async step.
+debugger; // B5 Continue
+
+late_resolve(3);
+
+%RunMicrotasks();
+
+assertEquals(8, step_count);
diff --git a/test/mjsunit/harmony/async-debug-step-in-and-out.js b/test/mjsunit/harmony/async-debug-step-in-and-out.js
new file mode 100644
index 0000000..30fe2d6
--- /dev/null
+++ b/test/mjsunit/harmony/async-debug-step-in-and-out.js
@@ -0,0 +1,51 @@
+// 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.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax --harmony-async-await
+
+var Debug = debug.Debug;
+var step_count = 0;
+
+function listener(event, execState, eventData, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var line = execState.frame(0).sourceLineText();
+ print(line);
+ var [match, expected_count, step] = /\/\/ B(\d) (\w+)$/.exec(line);
+ assertEquals(step_count++, parseInt(expected_count));
+ if (step != "Continue") execState.prepareStep(Debug.StepAction[step]);
+ } catch (e) {
+ print(e, e.stack);
+ quit(1);
+ }
+}
+
+Debug.setListener(listener);
+
+var late_resolve;
+
+function g() {
+ return new Promise( // B3 StepOut
+ function(res, rej) {
+ late_resolve = res;
+ }
+ );
+}
+
+async function f() {
+ var a = 1;
+ debugger; // B0 StepNext
+ a += // B1 StepNext
+ await // B4 StepNext
+ g(); // B2 StepIn
+ return a; // B5 StepNext
+} // B6 Continue
+
+f();
+
+late_resolve(3);
+
+%RunMicrotasks();
+
+assertEquals(7, step_count);
diff --git a/test/mjsunit/harmony/async-debug-step-in-out-out.js b/test/mjsunit/harmony/async-debug-step-in-out-out.js
new file mode 100644
index 0000000..c2f34bb
--- /dev/null
+++ b/test/mjsunit/harmony/async-debug-step-in-out-out.js
@@ -0,0 +1,51 @@
+// 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.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax --harmony-async-await
+
+var Debug = debug.Debug;
+var step_count = 0;
+
+function listener(event, execState, eventData, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var line = execState.frame(0).sourceLineText();
+ print(line);
+ var [match, expected_count, step] = /\/\/ B(\d) (\w+)$/.exec(line);
+ assertEquals(step_count++, parseInt(expected_count));
+ if (step != "Continue") execState.prepareStep(Debug.StepAction[step]);
+ } catch (e) {
+ print(e, e.stack);
+ quit(1);
+ }
+}
+
+Debug.setListener(listener);
+
+var late_resolve;
+
+function g() {
+ return new Promise( // B3 StepOut
+ function(res, rej) {
+ late_resolve = res;
+ }
+ );
+}
+
+async function f() {
+ var a = 1;
+ debugger; // B0 StepNext
+ a += // B1 StepNext
+ await // B4 StepOut
+ g(); // B2 StepIn
+ return a;
+}
+
+f();
+
+late_resolve(3); // B5 Continue
+
+%RunMicrotasks();
+
+assertEquals(6, step_count);
diff --git a/test/mjsunit/harmony/async-debug-step-in.js b/test/mjsunit/harmony/async-debug-step-in.js
new file mode 100644
index 0000000..0a7de1a
--- /dev/null
+++ b/test/mjsunit/harmony/async-debug-step-in.js
@@ -0,0 +1,51 @@
+// 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.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax --harmony-async-await
+
+var Debug = debug.Debug;
+var step_count = 0;
+
+function listener(event, execState, eventData, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var line = execState.frame(0).sourceLineText();
+ print(line);
+ var [match, expected_count, step] = /\/\/ B(\d) (\w+)$/.exec(line);
+ assertEquals(step_count++, parseInt(expected_count));
+ if (step != "Continue") execState.prepareStep(Debug.StepAction[step]);
+ } catch (e) {
+ print(e, e.stack);
+ quit(1);
+ }
+}
+
+Debug.setListener(listener);
+
+var late_resolve;
+
+function g() {
+ return new Promise( // B3 StepIn
+ function(res, rej) {
+ late_resolve = res; // B4 StepIn
+ } // B5 StepIn
+ );
+} // B6 StepIn
+
+async function f() {
+ var a = 1;
+ debugger; // B0 StepNext
+ a += // B1 StepIn
+ await // B7 StepIn
+ g(); // B2 StepIn
+ return a; // B8 StepIn
+} // B9 Continue
+
+f().then(value => assertEquals(4, value));
+
+late_resolve(3);
+
+%RunMicrotasks();
+
+assertEquals(10, step_count);
diff --git a/test/mjsunit/harmony/async-debug-step-nested.js b/test/mjsunit/harmony/async-debug-step-nested.js
new file mode 100644
index 0000000..adf7a51
--- /dev/null
+++ b/test/mjsunit/harmony/async-debug-step-nested.js
@@ -0,0 +1,58 @@
+// 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.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax --harmony-async-await
+
+var Debug = debug.Debug;
+var step_count = 0;
+
+function listener(event, execState, eventData, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var line = execState.frame(0).sourceLineText();
+ print(line);
+ var [match, expected_count, step] = /\/\/ B(\d) (\w+)$/.exec(line);
+ assertEquals(step_count++, parseInt(expected_count));
+ if (step != "Continue") execState.prepareStep(Debug.StepAction[step]);
+ } catch (e) {
+ print(e, e.stack);
+ quit(1);
+ }
+}
+
+Debug.setListener(listener);
+
+var late_resolve;
+
+function g() {
+ return new Promise( // B4 StepOut
+ function(res, rej) {
+ late_resolve = res;
+ }
+ );
+}
+
+async function f1() {
+ var a = 1;
+ debugger; // B0 StepNext
+ a += // B1 StepNext
+ await // B6 StepNext
+ f2(); // B2 StepIn
+ return a; // B7 StepNext
+} // B8 Continue
+
+async function f2() {
+ var b =
+ await // B5 StepOut
+ g(); // B3 StepIn
+ return b;
+}
+
+f1();
+
+late_resolve(3);
+
+%RunMicrotasks();
+
+assertEquals(9, step_count);
diff --git a/test/mjsunit/harmony/async-debug-step-next-constant.js b/test/mjsunit/harmony/async-debug-step-next-constant.js
new file mode 100644
index 0000000..cea86d7
--- /dev/null
+++ b/test/mjsunit/harmony/async-debug-step-next-constant.js
@@ -0,0 +1,39 @@
+// 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.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax --harmony-async-await
+
+var Debug = debug.Debug;
+var step_count = 0;
+
+function listener(event, execState, eventData, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var line = execState.frame(0).sourceLineText();
+ print(line);
+ var [match, expected_count, step] = /\/\/ B(\d) (\w+)$/.exec(line);
+ assertEquals(step_count++, parseInt(expected_count));
+ if (step != "Continue") execState.prepareStep(Debug.StepAction[step]);
+ } catch (e) {
+ print(e, e.stack);
+ quit(1);
+ }
+}
+
+Debug.setListener(listener);
+
+async function f() {
+ var a = 1;
+ debugger; // B0 StepNext
+ a += // B1 StepNext
+ await // B3 StepNext
+ 5; // B2 StepNext
+ return a; // B4 StepNext
+} // B5 Continue
+
+f();
+
+%RunMicrotasks();
+
+assertEquals(6, step_count);
diff --git a/test/mjsunit/harmony/async-debug-step-next.js b/test/mjsunit/harmony/async-debug-step-next.js
new file mode 100644
index 0000000..952d88d
--- /dev/null
+++ b/test/mjsunit/harmony/async-debug-step-next.js
@@ -0,0 +1,51 @@
+// 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.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax --harmony-async-await
+
+var Debug = debug.Debug;
+var step_count = 0;
+
+function listener(event, execState, eventData, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var line = execState.frame(0).sourceLineText();
+ print(line);
+ var [match, expected_count, step] = /\/\/ B(\d) (\w+)$/.exec(line);
+ assertEquals(step_count++, parseInt(expected_count));
+ if (step != "Continue") execState.prepareStep(Debug.StepAction[step]);
+ } catch (e) {
+ print(e, e.stack);
+ quit(1);
+ }
+}
+
+Debug.setListener(listener);
+
+var late_resolve;
+
+function g() {
+ return new Promise(
+ function(res, rej) {
+ late_resolve = res;
+ }
+ );
+}
+
+async function f() {
+ var a = 1;
+ debugger; // B0 StepNext
+ a += // B1 StepNext
+ await // B3 StepNext
+ g(); // B2 StepNext
+ return a; // B4 StepNext
+} // B5 Continue
+
+f();
+
+late_resolve(3);
+
+%RunMicrotasks();
+
+assertEquals(6, step_count);
diff --git a/test/mjsunit/harmony/async-debug-step-out.js b/test/mjsunit/harmony/async-debug-step-out.js
new file mode 100644
index 0000000..41779ac
--- /dev/null
+++ b/test/mjsunit/harmony/async-debug-step-out.js
@@ -0,0 +1,49 @@
+// 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.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax --harmony-async-await
+
+var Debug = debug.Debug;
+var step_count = 0;
+
+function listener(event, execState, eventData, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var line = execState.frame(0).sourceLineText();
+ print(line);
+ var [match, expected_count, step] = /\/\/ B(\d) (\w+)$/.exec(line);
+ assertEquals(step_count++, parseInt(expected_count));
+ if (step != "Continue") execState.prepareStep(Debug.StepAction[step]);
+ } catch (e) {
+ print(e, e.stack);
+ quit(1);
+ }
+}
+
+Debug.setListener(listener);
+
+var late_resolve;
+
+function g() {
+ return new Promise(
+ function(res, rej) {
+ late_resolve = res;
+ }
+ );
+}
+
+async function f() {
+ var a = 1;
+ debugger; // B0 StepNext
+ a += await g(); // B1 StepOut
+ return a;
+}
+
+f();
+
+late_resolve(3); // B2 Continue
+
+%RunMicrotasks();
+
+assertEquals(3, step_count);
diff --git a/test/mjsunit/harmony/async-function-debug-evaluate.js b/test/mjsunit/harmony/async-function-debug-evaluate.js
new file mode 100644
index 0000000..edf7bca
--- /dev/null
+++ b/test/mjsunit/harmony/async-function-debug-evaluate.js
@@ -0,0 +1,139 @@
+// 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.
+
+// Flags: --harmony-async-await --expose-debug-as debug
+
+var Debug = debug.Debug;
+var breakPointCount = 0;
+
+function listener(event, exec_state, event_data, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ ++breakPointCount;
+ try {
+ if (breakPointCount === 1) {
+ assertEquals(
+ "inner", exec_state.frame(0).evaluate("inner").value());
+ assertThrows(() => exec_state.frame(0).evaluate("letInner").value(),
+ ReferenceError);
+ assertThrows(() => exec_state.frame(0).evaluate("constInner").value(),
+ ReferenceError);
+
+ assertEquals("outer", exec_state.frame(0).evaluate("outer").value());
+ assertEquals(
+ "const outer", exec_state.frame(0).evaluate("constOuter").value());
+ assertEquals(
+ "let outer", exec_state.frame(0).evaluate("letOuter").value());
+
+ assertEquals("outer", exec_state.frame(1).evaluate("outer").value());
+ assertEquals(
+ "const outer", exec_state.frame(1).evaluate("constOuter").value());
+ assertEquals(
+ "let outer", exec_state.frame(1).evaluate("letOuter").value());
+
+ assertThrows(() => exec_state.frame(0).evaluate("withVar").value(),
+ ReferenceError);
+
+ } else if (breakPointCount === 2) {
+ assertEquals(
+ "inner", exec_state.frame(0).evaluate("inner").value());
+ assertThrows(() => exec_state.frame(0).evaluate("letInner").value(),
+ ReferenceError);
+ assertThrows(() => exec_state.frame(0).evaluate("constInner").value(),
+ ReferenceError);
+
+ assertEquals(57, exec_state.frame(0).evaluate("x").value());
+ assertEquals(100, exec_state.frame(0).evaluate("y").value());
+
+ // From breakPointCount === 1 and later, it's not possible to access
+ // earlier framestates.
+ assertEquals("outer", exec_state.frame(0).evaluate("outer").value());
+ assertEquals(
+ "const outer", exec_state.frame(0).evaluate("constOuter").value());
+ assertEquals(
+ "let outer", exec_state.frame(0).evaluate("letOuter").value());
+
+ exec_state.frame(0).evaluate("x = `x later(${x})`");
+ exec_state.frame(0).evaluate("y = `y later(${y})`");
+ exec_state.frame(0).evaluate("z = `ZEE`");
+
+ } else if (breakPointCount === 3) {
+ assertEquals(
+ "inner", exec_state.frame(0).evaluate("inner").value());
+ assertEquals(
+ "let inner", exec_state.frame(0).evaluate("letInner").value());
+ assertEquals(
+ "const inner", exec_state.frame(0).evaluate("constInner").value());
+
+ } else if (breakPointCount === 4) {
+ assertEquals(
+ "oop", exec_state.frame(0).evaluate("error.message").value());
+ assertEquals(
+ "Error",
+ exec_state.frame(0).evaluate("error.constructor.name").value());
+ assertEquals("floof", exec_state.frame(0).evaluate("bun").value());
+ assertThrows(() => exec_state.frame(0).evaluate("cow").value(),
+ ReferenceError);
+
+ assertEquals("outer", exec_state.frame(0).evaluate("outer").value());
+ assertEquals(
+ "const outer", exec_state.frame(0).evaluate("constOuter").value());
+ assertEquals(
+ "let outer", exec_state.frame(0).evaluate("letOuter").value());
+ }
+ } catch (e) {
+ print(e.stack);
+ quit(1);
+ }
+}
+
+Debug.setListener(listener);
+
+var outer = "outer";
+const constOuter = "const outer";
+let letOuter = "let outer"
+
+async function thrower() {
+ return Promise.reject(new Error("oop"));
+}
+
+async function testLater() {
+ return { x: 57, y: 100 };
+}
+
+async function test() {
+ var inner = "inner";
+ debugger;
+
+ let withVar = await testLater();
+ with (withVar) {
+ debugger;
+ }
+
+ assertEquals("x later(57)", withVar.x);
+ assertEquals("y later(100)", withVar.y);
+ assertEquals(undefined, withVar.z);
+ assertEquals("ZEE", z);
+
+ let letInner = "let inner";
+ const constInner = "const inner";
+ debugger;
+
+ try {
+ await thrower();
+ } catch (error) {
+ const bun = "floof";
+ debugger;
+ let cow = "moo";
+ }
+}
+
+test().
+then(x => {
+ Debug.setListener(null);
+}).
+catch(error => {
+ print(error.stack);
+ quit(1);
+ Debug.setListener(null);
+});
diff --git a/test/mjsunit/harmony/async-function-debug-scopes.js b/test/mjsunit/harmony/async-function-debug-scopes.js
new file mode 100644
index 0000000..3d72549
--- /dev/null
+++ b/test/mjsunit/harmony/async-function-debug-scopes.js
@@ -0,0 +1,616 @@
+// 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.
+
+// Flags: --harmony-async-await --expose-debug-as debug
+
+var Debug = debug.Debug;
+
+var AsyncFunction = (async function() {}).constructor;
+
+async function thrower() { throw 'Exception'; }
+
+async function test(name, func, args, handler, continuation) {
+ var handler_called = false;
+ var exception = null;
+
+ function listener(event, exec_state, event_data, data) {
+ try {
+ if (event == Debug.DebugEvent.Break) {
+ handler_called = true;
+ handler(exec_state);
+ }
+ } catch (e) {
+ exception = e;
+ }
+ }
+
+ Debug.setListener(listener);
+
+ var result;
+ if (typeof func === "object")
+ result = await func.method.apply(func, args);
+ else
+ result = await func.apply(null, args);
+
+ if (typeof continuation === "function") {
+ await continuation(result);
+ }
+
+ assertTrue(handler_called, `Expected ${name} handler to be called`);
+ if (exception) {
+ exception.message = `${name} / ${exception.message}`;
+ print(exception.stack);
+ quit(1);
+ }
+
+ Debug.setListener(null);
+}
+
+async function runTests() {
+
+// Simple
+await test(
+ "(AsyncFunctionExpression) Local 1",
+ async function() { debugger; }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({}, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 1 --- resume normal",
+ async function() { let z = await 2; debugger; }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({z: 2}, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 1 --- resume throw",
+ async function() { let q = await 1;
+ try { let z = await thrower(); }
+ catch (e) { debugger; } }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({e: 'Exception'}, 0, exec_state);
+ CheckScopeContent({q: 1}, 1, exec_state);
+
+ });
+
+// Simple With Parameter
+await test(
+ "(AsyncFunctionExpression) Local 2",
+ async function(a) { debugger; }, [1],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({ a: 1 }, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 2 --- resume normal",
+ async function(a) { let z = await 2; debugger; }, [1],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({ a: 1, z: 2 }, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 2 --- resume throw",
+ async function(a) { let z = await 2;
+ try { await thrower(); } catch (e) { debugger; } }, [1],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({ e: 'Exception' }, 0, exec_state);
+ CheckScopeContent({ a: 1, z: 2 }, 1, exec_state);
+ });
+
+// Simple With Parameter and Variable
+await test(
+ "(AsyncFunctionExpression) Local 3",
+ async function(a) { var b = 2; debugger; }, [1],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({ a: 1, b: 2 }, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 3 --- resume normal",
+ async function(a) { let y = await 3; var b = 2; let z = await 4;
+ debugger; }, [1],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({ a: 1, b: 2, y: 3, z: 4 }, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 3 --- resume throw",
+ async function(a) { let y = await 3;
+ try { var b = 2; let z = await thrower(); }
+ catch (e) { debugger; } }, [1],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({ e: 'Exception' }, 0, exec_state);
+ CheckScopeContent({ a: 1, b: 2, y: 3 }, 1, exec_state);
+ });
+
+// Local scope with parameters and local variables.
+await test(
+ "(AsyncFunctionExpression) Local 4",
+ async function(a, b) { var x = 3; var y = 4; debugger; }, [1, 2],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({a:1,b:2,x:3,y:4}, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 4 --- resume normal",
+ async function(a, b) { let q = await 5; var x = 3; var y = 4;
+ let r = await 6; debugger; }, [1, 2],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({a:1,b:2,x:3,y:4, q: 5, r: 6}, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 4 --- resume throw",
+ async function(a, b) { let q = await 5; var x = 3; var y = 4;
+ try { let r = await thrower(); }
+ catch (e) { debugger; } }, [1, 2],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({e: 'Exception'}, 0, exec_state);
+ CheckScopeContent({a:1,b:2,x:3,y:4, q: 5}, 1, exec_state);
+ });
+
+// Empty local scope with use of eval.
+await test(
+ "(AsyncFunctionExpression) Local 5",
+ async function() { eval(""); debugger; }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({}, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 5 --- resume normal",
+ async function() { let x = await 1; eval(""); let y = await 2;
+ debugger; }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({ x: 1, y: 2 }, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 5 --- resume throw",
+ async function() { let x = await 1; eval("");
+ try { let y = await thrower(); }
+ catch (e) { debugger; } }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({ e: 'Exception' }, 0, exec_state);
+ CheckScopeContent({ x: 1 }, 1, exec_state);
+ });
+
+// Local introducing local variable using eval.
+await test(
+ "(AsyncFunctionExpression) Local 6",
+ async function() { eval("var i = 5"); debugger; }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({i:5}, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 6 --- resume normal",
+ async function() { let x = await 1; eval("var i = 5"); let y = await 2;
+ debugger; }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({i:5, x: 1, y: 2}, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 6 --- resume throw",
+ async function() { let x = await 1; eval("var i = 5");
+ try { let y = await thrower(); }
+ catch (e) { debugger; } }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({e: 'Exception' }, 0, exec_state);
+ CheckScopeContent({i:5, x: 1}, 1, exec_state);
+ });
+
+// Local scope with parameters, local variables and local variable introduced
+// using eval.
+await test(
+ "(AsyncFunctionExpression) Local 7",
+ async function(a, b) { var x = 3; var y = 4;
+ eval("var i = 5;"); eval("var j = 6");
+ debugger; }, [1, 2],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6}, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 7 --- resume normal",
+ async function(a, b) { let z = await 7; var x = 3; var y = 4;
+ eval("var i = 5;"); eval("var j = 6");
+ let q = await 8;
+ debugger; }, [1, 2],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6, z:7, q:8}, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Local 7 --- resume throw",
+ async function(a, b) { let z = await 7; var x = 3; var y = 4;
+ eval("var i = 5;"); eval("var j = 6");
+ try { let q = await thrower(); }
+ catch (e) { debugger; } }, [1, 2],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({e: 'Exception'}, 0, exec_state);
+ //CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6, z:7}, 1, exec_state);
+ });
+
+// Nested empty with blocks.
+await test(
+ "(AsyncFunctionExpression) With",
+ async function() { with ({}) { with ({}) { debugger; } } }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.With,
+ debug.ScopeType.With,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({}, 0, exec_state);
+ CheckScopeContent({}, 1, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) With --- resume normal",
+ async function() { let x = await 1; with ({}) { with ({}) {
+ let y = await 2; debugger; } } }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Block,
+ debug.ScopeType.With,
+ debug.ScopeType.With,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({y:2}, 0, exec_state);
+ CheckScopeContent({}, 1, exec_state);
+ CheckScopeContent({}, 2, exec_state);
+ CheckScopeContent({x:1}, 3, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) With --- resume throw",
+ async function() { let x = await 1; with ({}) { with ({}) {
+ try { let y = await thrower(); }
+ catch (e) { debugger; } } } }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.With,
+ debug.ScopeType.With,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({ e: 'Exception'}, 0, exec_state);
+ CheckScopeContent({}, 1, exec_state);
+ CheckScopeContent({}, 2, exec_state);
+ CheckScopeContent({x:1}, 3, exec_state);
+ });
+
+// Simple closure formed by returning an inner function referering the outer
+// functions arguments.
+await test(
+ "(AsyncFunctionExpression) Closure 1",
+ async function(a) { return function() { debugger; return a; } }, [1],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({a:1}, 1, exec_state);
+ },
+ result => result());
+
+await test(
+ "(AsyncFunctionExpression) Closure 1 --- resume normal",
+ async function(a) { let x = await 2;
+ return function() { debugger; return a; } }, [1],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({a:1, x: 2}, 1, exec_state);
+ },
+ result => result());
+
+await test(
+ "(AsyncFunctionExpression) Closure 1 --- resume throw",
+ async function(a) { let x = await 2;
+ return async function() {
+ try { await thrower(); }
+ catch (e) { debugger; } return a; }; }, [1],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({e: 'Exception'}, 0, exec_state);
+ CheckScopeContent({a:1, x: 2}, 2, exec_state);
+ },
+ result => result());
+
+await test(
+ "(AsyncFunctionExpression) Catch block 1",
+ async function() { try { throw 'Exception'; } catch (e) { debugger; } }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({e:'Exception'}, 0, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Catch block 1 --- resume normal",
+ async function() {
+ let x = await 1;
+ try { throw 'Exception'; } catch (e) { let y = await 2; debugger; } }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Block,
+ debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({y: 2}, 0, exec_state);
+ CheckScopeContent({e:'Exception'}, 1, exec_state);
+ CheckScopeContent({x: 1}, 2, exec_state);
+ });
+
+await test(
+ "(AsyncFunctionExpression) Catch block 1 --- resume throw",
+ async function() {
+ let x = await 1;
+ try { throw 'Exception!'; } catch (e) {
+ try { let y = await thrower(); } catch (e) { debugger; } } }, [],
+ exec_state => {
+ CheckScopeChain([debug.ScopeType.Catch,
+ debug.ScopeType.Catch,
+ debug.ScopeType.Local,
+ debug.ScopeType.Closure,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global], exec_state);
+ CheckScopeContent({e:'Exception'}, 0, exec_state);
+ CheckScopeContent({e:'Exception!'}, 1, exec_state);
+ CheckScopeContent({x: 1}, 2, exec_state);
+ });
+}
+
+runTests().catch(error => {
+ print(error.stack);
+ quit(1);
+})
+
+// Check that two scope are the same.
+function assertScopeMirrorEquals(scope1, scope2) {
+ assertEquals(scope1.scopeType(), scope2.scopeType());
+ assertEquals(scope1.frameIndex(), scope2.frameIndex());
+ assertEquals(scope1.scopeIndex(), scope2.scopeIndex());
+ assertPropertiesEqual(
+ scope1.scopeObject().value(), scope2.scopeObject().value());
+}
+
+function CheckFastAllScopes(scopes, exec_state) {
+ var fast_all_scopes = exec_state.frame().allScopes(true);
+ var length = fast_all_scopes.length;
+ assertTrue(scopes.length >= length);
+ for (var i = 0; i < scopes.length && i < length; i++) {
+ var scope = fast_all_scopes[length - i - 1];
+ assertTrue(scope.isScope());
+ assertEquals(scopes[scopes.length - i - 1], scope.scopeType());
+ }
+}
+
+// Check that the scope chain contains the expected types of scopes.
+function CheckScopeChain(scopes, exec_state) {
+ var all_scopes = exec_state.frame().allScopes();
+ assertEquals(
+ scopes.length, all_scopes.length, "FrameMirror.allScopes length");
+ for (var i = 0; i < scopes.length; i++) {
+ var scope = exec_state.frame().scope(i);
+ assertTrue(scope.isScope());
+ assertEquals(scopes[i], scope.scopeType());
+ assertScopeMirrorEquals(all_scopes[i], scope);
+
+ // Check the global object when hitting the global scope.
+ if (scopes[i] == debug.ScopeType.Global) {
+ // Objects don't have same class (one is "global", other is "Object",
+ // so just check the properties directly.
+ assertPropertiesEqual(this, scope.scopeObject().value());
+ }
+ }
+ CheckFastAllScopes(scopes, exec_state);
+
+ // Get the debug command processor.
+ var dcp = exec_state.debugCommandProcessor("unspecified_running_state");
+
+ // Send a scopes request and check the result.
+ var json;
+ var request_json = '{"seq":0,"type":"request","command":"scopes"}';
+ var response_json = dcp.processDebugJSONRequest(request_json);
+ var response = JSON.parse(response_json);
+ assertEquals(scopes.length, response.body.scopes.length);
+ for (var i = 0; i < scopes.length; i++) {
+ var scopeRef = response.body.scopes[i].object.ref;
+ assertEquals(i, response.body.scopes[i].index);
+ assertEquals(scopes[i], response.body.scopes[i].type);
+ if (scopes[i] == debug.ScopeType.Local ||
+ scopes[i] == debug.ScopeType.Script ||
+ scopes[i] == debug.ScopeType.Closure) {
+ assertTrue(response.body.scopes[i].object.ref < 0);
+ } else {
+ assertTrue(response.body.scopes[i].object.ref >= 0);
+ }
+ var found = false;
+ for (var j = 0; j < response.refs.length && !found; j++) {
+ found = response.refs[j].handle == response.body.scopes[i].object.ref;
+ }
+ assertTrue(found, `Scope object ${scopeRef} not found`);
+ }
+}
+
+// Check that the content of the scope is as expected. For functions just check
+// that there is a function.
+function CheckScopeContent(content, number, exec_state) {
+ var scope = exec_state.frame().scope(number);
+ var count = 0;
+ for (var p in content) {
+ var property_mirror = scope.scopeObject().property(p);
+ assertFalse(property_mirror.isUndefined(),
+ `property ${p} not found in scope`);
+ if (typeof(content[p]) === 'function') {
+ assertTrue(property_mirror.value().isFunction());
+ } else {
+ assertEquals(content[p], property_mirror.value().value(),
+ `property ${p} has unexpected value`);
+ }
+ count++;
+ }
+
+ // 'arguments' and might be exposed in the local and closure scope. Just
+ // ignore this.
+ var scope_size = scope.scopeObject().properties().length;
+ if (!scope.scopeObject().property('arguments').isUndefined()) {
+ scope_size--;
+ }
+ // Skip property with empty name.
+ if (!scope.scopeObject().property('').isUndefined()) {
+ scope_size--;
+ }
+
+ if (count != scope_size) {
+ print('Names found in scope:');
+ var names = scope.scopeObject().propertyNames();
+ for (var i = 0; i < names.length; i++) {
+ print(names[i]);
+ }
+ }
+ assertEquals(count, scope_size);
+
+ // Get the debug command processor.
+ var dcp = exec_state.debugCommandProcessor("unspecified_running_state");
+
+ // Send a scope request for information on a single scope and check the
+ // result.
+ var request_json = `{
+ "seq": 0,
+ "type": "request",
+ "command": "scope",
+ "arguments": {
+ "number": `;
+ request_json += scope.scopeIndex();
+ request_json += '}}';
+ var response_json = dcp.processDebugJSONRequest(request_json);
+ var response = JSON.parse(response_json);
+ assertEquals(scope.scopeType(), response.body.type);
+ assertEquals(number, response.body.index);
+ if (scope.scopeType() == debug.ScopeType.Local ||
+ scope.scopeType() == debug.ScopeType.Script ||
+ scope.scopeType() == debug.ScopeType.Closure) {
+ assertTrue(response.body.object.ref < 0);
+ } else {
+ assertTrue(response.body.object.ref >= 0);
+ }
+ var found = false;
+ for (var i = 0; i < response.refs.length && !found; i++) {
+ found = response.refs[i].handle == response.body.object.ref;
+ }
+ assertTrue(found, "Scope object " + response.body.object.ref + " not found");
+}
diff --git a/test/mjsunit/harmony/async-function-stacktrace.js b/test/mjsunit/harmony/async-function-stacktrace.js
new file mode 100644
index 0000000..50df44d
--- /dev/null
+++ b/test/mjsunit/harmony/async-function-stacktrace.js
@@ -0,0 +1,115 @@
+// 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.
+
+// Flags: --harmony-async-await
+
+async function test(func, funcs) {
+ try {
+ await func();
+ throw new Error("Expected " + func.toString() + " to throw");
+ } catch (e) {
+ var stack = e.stack.split('\n').
+ slice(1).
+ map(line => line.trim()).
+ map(line => line.match(/at (?:(.*) )?.*$/)[1]).
+ filter(x => typeof x === 'string' && x.length);
+
+ assertEquals(funcs, stack, `Unexpected stack trace ${e.stack}`);
+ }
+}
+
+function thrower() { throw new Error("NOPE"); }
+function reject() { return Promise.reject(new Error("NOPE")); }
+
+async function runTests() {
+ await test(async function a() {
+ throw new Error("FAIL");
+ },
+ ["a", "test", "runTests"]);
+
+ await test(async function a2() {
+ await 1;
+ throw new Error("FAIL");
+ }, ["a2"]);
+
+ await test(async function a3() {
+ await 1;
+ try { await thrower(); } catch (e) { throw new Error("FAIL"); }
+ }, ["a3"]);
+
+ await test(async function a4() {
+ await 1;
+ try { await reject(); } catch (e) { throw new Error("FAIL"); }
+ }, ["a4"]);
+
+ await test({ async b() {
+ throw new Error("FAIL");
+ }}.b,
+ ["b", "test", "runTests"]);
+
+ await test({ async b2() {
+ await 1;
+ throw new Error("FAIL");
+ }}.b2, ["b2"]);
+
+ await test({ async b3() {
+ await 1;
+ try { await thrower(); } catch (e) { throw new Error("FAIL"); }
+ } }.b3, ["b3"]);
+
+ await test({ async b4() {
+ await 1;
+ try { await reject(); } catch (e) { throw new Error("FAIL"); }
+ } }.b4, ["b4"]);
+
+ await test((new class { async c() {
+ throw new Error("FAIL");
+ } }).c,
+ ["c", "test", "runTests"]);
+
+ await test((new class { async c2() {
+ await 1;
+ throw new Error("FAIL");
+ } }).c2, ["c2"]);
+
+ await test((new class { async c3() {
+ await 1;
+ try { await thrower(); } catch (e) { throw new Error("FAIL"); }
+ } }).c3, ["c3"]);
+
+ await test((new class { async c4() {
+ await 1;
+ try { await reject(); } catch (e) { throw new Error("FAIL"); }
+ } }).c4, ["c4"]);
+
+ // TODO(caitp): `async` probably shouldn't be the inferred name for async
+ // arrow functions...
+ await test(async() => { throw new Error("FAIL") },
+ ["async", "test", "runTests"]);
+
+ await test(async() => { await 1; throw new Error("FAIL") }, ["async"]);
+
+ await test(async() => {
+ await 1;
+ try {
+ await thrower();
+ } catch (e) {
+ throw new Error("FAIL");
+ }
+ }, ["e"]); // TODO(caitp): FuncNameInferer is doing some weird stuff...
+
+ await test(async() => {
+ await 1;
+ try {
+ await reject();
+ } catch (e) {
+ throw new Error("FAIL");
+ }
+ }, ["e"]);
+}
+
+runTests().catch(e => {
+ print(e);
+ quit(1);
+});
diff --git a/test/mjsunit/harmony/debug-async-break-on-stack.js b/test/mjsunit/harmony/debug-async-break-on-stack.js
new file mode 100644
index 0000000..d3d9d8b
--- /dev/null
+++ b/test/mjsunit/harmony/debug-async-break-on-stack.js
@@ -0,0 +1,78 @@
+// 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.
+
+// Flags: --expose-debug-as debug
+// Flags: --harmony-async-await --allow-natives-syntax
+
+var Debug = debug.Debug;
+
+function assertEqualsAsync(expected, run, msg) {
+ var actual;
+ var hadValue = false;
+ var hadError = false;
+ var promise = run();
+
+ if (typeof promise !== "object" || typeof promise.then !== "function") {
+ throw new MjsUnitAssertionError(
+ "Expected " + run.toString() +
+ " to return a Promise, but it returned " + promise);
+ }
+
+ promise.then(function(value) { hadValue = true; actual = value; },
+ function(error) { hadError = true; actual = error; });
+
+ assertFalse(hadValue || hadError);
+
+ %RunMicrotasks();
+
+ if (hadError) throw actual;
+
+ assertTrue(
+ hadValue, "Expected '" + run.toString() + "' to produce a value");
+
+ assertEquals(expected, actual, msg);
+}
+
+var break_count = 0;
+var exception = null;
+
+function listener(event, exec_state, event_data, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ break_count++;
+ var line = exec_state.frame(0).sourceLineText();
+ print(line);
+ assertTrue(line.indexOf(`B${break_count}`) > 0);
+ } catch (e) {
+ exception = e;
+ }
+}
+
+
+async function g() {
+ setbreaks();
+ throw 1; // B1
+}
+
+async function f() {
+ try {
+ await g();
+ } catch (e) {}
+ return 2; // B2
+}
+
+function setbreaks() {
+ Debug.setListener(listener);
+ Debug.setBreakPoint(g, 2);
+ Debug.setBreakPoint(f, 4);
+}
+
+f();
+
+%RunMicrotasks();
+
+assertEqualsAsync(2, async () => break_count);
+assertEqualsAsync(null, async () => exception);
+
+Debug.setListener(null);
diff --git a/test/mjsunit/harmony/debug-async-break.js b/test/mjsunit/harmony/debug-async-break.js
new file mode 100644
index 0000000..3b6b71b
--- /dev/null
+++ b/test/mjsunit/harmony/debug-async-break.js
@@ -0,0 +1,76 @@
+// 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.
+
+// Flags: --expose-debug-as debug
+// Flags: --harmony-async-await --allow-natives-syntax
+
+var Debug = debug.Debug;
+
+function assertEqualsAsync(expected, run, msg) {
+ var actual;
+ var hadValue = false;
+ var hadError = false;
+ var promise = run();
+
+ if (typeof promise !== "object" || typeof promise.then !== "function") {
+ throw new MjsUnitAssertionError(
+ "Expected " + run.toString() +
+ " to return a Promise, but it returned " + promise);
+ }
+
+ promise.then(function(value) { hadValue = true; actual = value; },
+ function(error) { hadError = true; actual = error; });
+
+ assertFalse(hadValue || hadError);
+
+ %RunMicrotasks();
+
+ if (hadError) throw actual;
+
+ assertTrue(
+ hadValue, "Expected '" + run.toString() + "' to produce a value");
+
+ assertEquals(expected, actual, msg);
+}
+
+var break_count = 0;
+var exception = null;
+
+function listener(event, exec_state, event_data, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ break_count++;
+ var line = exec_state.frame(0).sourceLineText();
+ assertTrue(line.indexOf(`B${break_count}`) > 0);
+ } catch (e) {
+ exception = e;
+ }
+}
+
+Debug.setListener(listener);
+
+async function g() {
+ throw 1;
+}
+
+async function f() {
+ try {
+ await g(); // B1
+ } catch (e) {}
+ assertEquals(2, break_count); // B2
+ return 1; // B3
+}
+
+Debug.setBreakPoint(f, 2);
+Debug.setBreakPoint(f, 4);
+Debug.setBreakPoint(f, 5);
+
+f();
+
+%RunMicrotasks();
+
+assertEqualsAsync(3, async () => break_count);
+assertEqualsAsync(null, async () => exception);
+
+Debug.setListener(null);
diff --git a/test/mjsunit/harmony/debug-async-function-async-task-event.js b/test/mjsunit/harmony/debug-async-function-async-task-event.js
new file mode 100644
index 0000000..249f02f
--- /dev/null
+++ b/test/mjsunit/harmony/debug-async-function-async-task-event.js
@@ -0,0 +1,70 @@
+// 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.
+
+// Flags: --harmony-async-await --expose-debug-as debug --allow-natives-syntax
+
+Debug = debug.Debug;
+
+var base_id = -1;
+var exception = null;
+var expected = [
+ "enqueue #1",
+ "willHandle #1",
+ "then #1",
+ "enqueue #2",
+ "enqueue #3",
+ "didHandle #1",
+ "willHandle #2",
+ "then #2",
+ "didHandle #2",
+ "willHandle #3",
+ "enqueue #4",
+ "didHandle #3",
+ "willHandle #4",
+ "didHandle #4",
+];
+
+function assertLog(msg) {
+ print(msg);
+ assertTrue(expected.length > 0);
+ assertEquals(expected.shift(), msg);
+ if (!expected.length) {
+ Debug.setListener(null);
+ }
+}
+
+function listener(event, exec_state, event_data, data) {
+ if (event != Debug.DebugEvent.AsyncTaskEvent) return;
+ try {
+ if (base_id < 0)
+ base_id = event_data.id();
+ var id = event_data.id() - base_id + 1;
+ assertTrue("Promise.resolve" == event_data.name() ||
+ "PromiseResolveThenableJob" == event_data.name());
+ assertLog(event_data.type() + " #" + id);
+ } catch (e) {
+ print(e + e.stack)
+ exception = e;
+ }
+}
+
+Debug.setListener(listener);
+
+var resolver;
+var p = new Promise(function(resolve, reject) {
+ resolver = resolve;
+});
+
+async function main() {
+ await p;
+ assertLog("then #1");
+ await undefined;
+ assertLog("then #2");
+}
+main();
+resolver();
+
+%RunMicrotasks();
+
+assertNull(exception);
diff --git a/test/mjsunit/harmony/debug-async-liveedit.js b/test/mjsunit/harmony/debug-async-liveedit.js
new file mode 100644
index 0000000..c651ddb
--- /dev/null
+++ b/test/mjsunit/harmony/debug-async-liveedit.js
@@ -0,0 +1,133 @@
+// 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.
+
+// Flags: --harmony-async-await
+// Flags: --expose-debug-as debug --allow-natives-syntax --ignition-generators
+
+var Debug = debug.Debug;
+var LiveEdit = Debug.LiveEdit;
+
+unique_id = 0;
+
+var AsyncFunction = (async function(){}).constructor;
+
+function assertPromiseValue(value, promise) {
+ promise.then(resolve => {
+ went = true;
+ if (resolve !== value) {
+ print(`expected ${value} found ${resolve}`);
+ quit(1);
+ }
+ }, reject => {
+ print(`rejected ${reject}`);
+ quit(1);
+ });
+}
+
+function MakeAsyncFunction() {
+ // Prevents eval script caching.
+ unique_id++;
+ return AsyncFunction('callback',
+ "/* " + unique_id + "*/\n" +
+ "await callback();\n" +
+ "return 'Cat';\n");
+}
+
+function MakeFunction() {
+ // Prevents eval script caching.
+ unique_id++;
+ return Function('callback',
+ "/* " + unique_id + "*/\n" +
+ "callback();\n" +
+ "return 'Cat';\n");
+}
+
+// First, try MakeGenerator with no perturbations.
+(function(){
+ var asyncfn = MakeAsyncFunction();
+ function callback() {};
+ var promise = asyncfn(callback);
+ assertPromiseValue('Cat', promise);
+})();
+
+function patch(fun, from, to) {
+ function debug() {
+ var log = new Array();
+ var script = Debug.findScript(fun);
+ var pos = script.source.indexOf(from);
+ print(`pos ${pos}`);
+ try {
+ LiveEdit.TestApi.ApplySingleChunkPatch(script, pos, from.length, to,
+ log);
+ } finally {
+ print("Change log: " + JSON.stringify(log) + "\n");
+ }
+ }
+ %ExecuteInDebugContext(debug);
+}
+
+// Try to edit a MakeAsyncFunction while it's running, then again while it's
+// stopped.
+(function(){
+ var asyncfn = MakeAsyncFunction();
+
+ var patch_attempted = false;
+ function attempt_patch() {
+ assertFalse(patch_attempted);
+ patch_attempted = true;
+ assertThrows(function() { patch(asyncfn, "'Cat'", "'Capybara'") },
+ LiveEdit.Failure);
+ };
+ var promise = asyncfn(attempt_patch);
+ // Patch should not succeed because there is a live async function activation
+ // on the stack.
+ assertPromiseValue("Cat", promise);
+ assertTrue(patch_attempted);
+
+ %RunMicrotasks();
+
+ // At this point one iterator is live, but closed, so the patch will succeed.
+ patch(asyncfn, "'Cat'", "'Capybara'");
+ promise = asyncfn(function(){});
+ // Patch successful.
+ assertPromiseValue("Capybara", promise);
+
+ // Patching will fail however when an async function is suspended.
+ var resolve;
+ promise = asyncfn(function(){return new Promise(function(r){resolve = r})});
+ assertThrows(function() { patch(asyncfn, "'Capybara'", "'Tapir'") },
+ LiveEdit.Failure);
+ resolve();
+ assertPromiseValue("Capybara", promise);
+
+ // Try to patch functions with activations inside and outside async
+ // function activations. We should succeed in the former case, but not in the
+ // latter.
+ var fun_outside = MakeFunction();
+ var fun_inside = MakeFunction();
+ var fun_patch_attempted = false;
+ var fun_patch_restarted = false;
+ function attempt_fun_patches() {
+ if (fun_patch_attempted) {
+ assertFalse(fun_patch_restarted);
+ fun_patch_restarted = true;
+ return;
+ }
+ fun_patch_attempted = true;
+ // Patching outside an async function activation must fail.
+ assertThrows(function() { patch(fun_outside, "'Cat'", "'Cobra'") },
+ LiveEdit.Failure);
+ // Patching inside an async function activation may succeed.
+ patch(fun_inside, "'Cat'", "'Koala'");
+ }
+ promise = asyncfn(function() { return fun_inside(attempt_fun_patches) });
+ assertEquals('Cat',
+ fun_outside(function () {
+ assertPromiseValue('Capybara', promise);
+ assertTrue(fun_patch_restarted);
+ assertTrue(fun_inside.toString().includes("'Koala'"));
+ }));
+})();
+
+%RunMicrotasks();
diff --git a/test/mjsunit/harmony/generators-turbo.js b/test/mjsunit/harmony/generators-turbo.js
new file mode 100644
index 0000000..23913e4
--- /dev/null
+++ b/test/mjsunit/harmony/generators-turbo.js
@@ -0,0 +1,655 @@
+// 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.
+
+// Flags: --ignition --ignition-generators --harmony-do-expressions
+// Flags: --allow-natives-syntax --turbo --turbo-from-bytecode
+
+
+// This file is identical to mjsunit/harmony/generators.js, except for its Flags
+// lines. The purpose is to explicitly mention --turbo-from-bytecode such that
+// Clusterfuzz can thoroughly test the new generators implementation.
+
+
+function MaybeOptimizeOrDeoptimize(f) {
+ let x = Math.random(); // --random-seed makes this deterministic
+ if (x <= 0.33) {
+ %OptimizeFunctionOnNextCall(f);
+ } else if (x <= 0.66) {
+ %DeoptimizeFunction(f);
+ }
+}
+
+function Next(generator, ...args) {
+ MaybeOptimizeOrDeoptimize(%GeneratorGetFunction(generator));
+ return generator.next(...args);
+}
+
+function Return(generator, ...args) {
+ MaybeOptimizeOrDeoptimize(%GeneratorGetFunction(generator));
+ return generator.return(...args);
+}
+
+function Throw(generator, ...args) {
+ MaybeOptimizeOrDeoptimize(%GeneratorGetFunction(generator));
+ return generator.throw(...args);
+}
+
+
+{ // yield in try-catch
+
+ let g = function*() {
+ try {yield 1} catch (error) {assertEquals("caught", error)}
+ };
+
+ assertThrowsEquals(() => Throw(g(), "not caught"), "not caught");
+
+ {
+ let x = g();
+ assertEquals({value: 1, done: false}, Next(x));
+ assertEquals({value: undefined, done: true}, Throw(x, "caught"));
+ }
+
+ {
+ let x = g();
+ assertEquals({value: 1, done: false}, Next(x));
+ assertEquals({value: undefined, done: true}, Next(x));
+ assertThrowsEquals(() => Throw(x, "not caught"), "not caught");
+ }
+}
+
+
+{ // return that doesn't close
+ let g = function*() { try {return 42} finally {yield 43} };
+
+ {
+ let x = g();
+ assertEquals({value: 43, done: false}, Next(x));
+ assertEquals({value: 42, done: true}, Next(x));
+ }
+}
+
+
+{ // return that doesn't close
+ let x;
+ let g = function*() { try {return 42} finally {Throw(x, 666)} };
+
+ {
+ x = g();
+ assertThrows(() => Next(x), TypeError); // still executing
+ }
+}
+
+
+{ // yield in try-finally, finally clause performs return
+
+ let g = function*() { try {yield 42} finally {return 13} };
+
+ { // "return" closes at suspendedStart
+ let x = g();
+ assertEquals({value: 666, done: true}, Return(x, 666));
+ assertEquals({value: undefined, done: true}, Next(x, 42));
+ assertThrowsEquals(() => Throw(x, 43), 43);
+ assertEquals({value: 42, done: true}, Return(x, 42));
+ }
+
+ { // "throw" closes at suspendedStart
+ let x = g();
+ assertThrowsEquals(() => Throw(x, 666), 666);
+ assertEquals({value: undefined, done: true}, Next(x, 42));
+ assertEquals({value: 43, done: true}, Return(x, 43));
+ assertThrowsEquals(() => Throw(x, 44), 44);
+ }
+
+ { // "next" closes at suspendedYield
+ let x = g();
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 13, done: true}, Next(x, 666));
+ assertEquals({value: undefined, done: true}, Next(x, 666));
+ assertThrowsEquals(() => Throw(x, 666), 666);
+ }
+
+ { // "return" closes at suspendedYield
+ let x = g();
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 13, done: true}, Return(x, 666));
+ assertEquals({value: undefined, done: true}, Next(x, 666));
+ assertEquals({value: 666, done: true}, Return(x, 666));
+ }
+
+ { // "throw" closes at suspendedYield
+ let x = g();
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 13, done: true}, Throw(x, 666));
+ assertThrowsEquals(() => Throw(x, 666), 666);
+ assertEquals({value: undefined, done: true}, Next(x, 666));
+ }
+}
+
+
+{ // yield in try-finally, finally clause doesn't perform return
+
+ let g = function*() { try {yield 42} finally {13} };
+
+ { // "return" closes at suspendedStart
+ let x = g();
+ assertEquals({value: 666, done: true}, Return(x, 666));
+ assertEquals({value: undefined, done: true}, Next(x, 42));
+ assertThrowsEquals(() => Throw(x, 43), 43);
+ assertEquals({value: 42, done: true}, Return(x, 42));
+ }
+
+ { // "throw" closes at suspendedStart
+ let x = g();
+ assertThrowsEquals(() => Throw(x, 666), 666);
+ assertEquals({value: undefined, done: true}, Next(x, 42));
+ assertEquals({value: 43, done: true}, Return(x, 43));
+ assertThrowsEquals(() => Throw(x, 44), 44);
+ }
+
+ { // "next" closes at suspendedYield
+ let x = g();
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: undefined, done: true}, Next(x, 666));
+ assertEquals({value: undefined, done: true}, Next(x, 666));
+ assertThrowsEquals(() => Throw(x, 666), 666);
+ assertEquals({value: 42, done: true}, Return(x, 42));
+ }
+
+ { // "return" closes at suspendedYield
+ let x = g();
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 666, done: true}, Return(x, 666));
+ assertEquals({value: undefined, done: true}, Next(x, 666));
+ assertThrowsEquals(() => Throw(x, 44), 44);
+ assertEquals({value: 42, done: true}, Return(x, 42));
+ }
+
+ { // "throw" closes at suspendedYield
+ let x = g();
+ assertEquals({value: 42, done: false}, Next(x));
+ assertThrowsEquals(() => Throw(x, 666), 666);
+ assertEquals({value: undefined, done: true}, Next(x, 666));
+ assertThrowsEquals(() => Throw(x, 666), 666);
+ assertEquals({value: 42, done: true}, Return(x, 42));
+ }
+}
+
+
+{ // yield in try-finally, finally clause yields and performs return
+
+ let g = function*() { try {yield 42} finally {yield 43; return 13} };
+
+ {
+ let x = g();
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 43, done: false}, Return(x, 666));
+ assertEquals({value: 13, done: true}, Next(x));
+ assertEquals({value: 666, done: true}, Return(x, 666));
+ }
+
+ {
+ let x = g();
+ assertEquals({value: 666, done: true}, Return(x, 666));
+ assertEquals({value: undefined, done: true}, Next(x));
+ assertEquals({value: 666, done: true}, Return(x, 666));
+ }
+}
+
+
+{ // yield in try-finally, finally clause yields and doesn't perform return
+
+ let g = function*() { try {yield 42} finally {yield 43; 13} };
+
+ {
+ let x = g();
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 43, done: false}, Return(x, 666));
+ assertEquals({value: 666, done: true}, Next(x));
+ assertEquals({value: 5, done: true}, Return(x, 5));
+ }
+
+ {
+ let x = g();
+ assertEquals({value: 666, done: true}, Return(x, 666));
+ assertEquals({value: undefined, done: true}, Next(x));
+ assertEquals({value: 666, done: true}, Return(x, 666));
+ }
+}
+
+
+{ // yield*, finally clause performs return
+
+ let h = function*() { try {yield 42} finally {yield 43; return 13} };
+ let g = function*() { yield 1; yield yield* h(); };
+
+ {
+ let x = g();
+ assertEquals({value: 1, done: false}, Next(x));
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 43, done: false}, Next(x, 666));
+ assertEquals({value: 13, done: false}, Next(x));
+ assertEquals({value: undefined, done: true}, Next(x));
+ }
+
+ {
+ let x = g();
+ assertEquals({value: 1, done: false}, Next(x));
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 43, done: false}, Return(x, 666));
+ assertEquals({value: 13, done: false}, Next(x));
+ assertEquals({value: undefined, done: true}, Next(x));
+ }
+
+ {
+ let x = g();
+ assertEquals({value: 1, done: false}, Next(x));
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 43, done: false}, Throw(x, 666));
+ assertEquals({value: 13, done: false}, Next(x));
+ assertEquals({value: undefined, done: true}, Next(x));
+ }
+}
+
+
+{ // yield*, finally clause does not perform return
+
+ let h = function*() { try {yield 42} finally {yield 43; 13} };
+ let g = function*() { yield 1; yield yield* h(); };
+
+ {
+ let x = g();
+ assertEquals({value: 1, done: false}, Next(x));
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 43, done: false}, Next(x, 666));
+ assertEquals({value: undefined, done: false}, Next(x));
+ assertEquals({value: undefined, done: true}, Next(x));
+ }
+
+ {
+ let x = g();
+ assertEquals({value: 1, done: false}, Next(x));
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 43, done: false}, Return(x, 44));
+ assertEquals({value: 44, done: false}, Next(x));
+ assertEquals({value: undefined, done: true}, Next(x));
+ }
+
+ {
+ let x = g();
+ assertEquals({value: 1, done: false}, Next(x));
+ assertEquals({value: 42, done: false}, Next(x));
+ assertEquals({value: 43, done: false}, Throw(x, 666));
+ assertThrowsEquals(() => Next(x), 666);
+ }
+}
+
+
+{ // yield*, .return argument is final result
+
+ function* inner() {
+ yield 2;
+ }
+
+ function* g() {
+ yield 1;
+ return yield* inner();
+ }
+
+ {
+ let x = g();
+ assertEquals({value: 1, done: false}, Next(x));
+ assertEquals({value: 2, done: false}, Next(x));
+ assertEquals({value: 42, done: true}, Return(x, 42));
+ }
+}
+
+
+// More or less random tests from here on.
+
+
+{
+ function* foo() { }
+ let g = foo();
+ assertEquals({value: undefined, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ function* foo() { return new.target }
+ let g = foo();
+ assertEquals({value: undefined, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ function* foo() { throw 666; return 42}
+ let g = foo();
+ assertThrowsEquals(() => Next(g), 666);
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ function* foo(a) { return a; }
+ let g = foo(42);
+ assertEquals({value: 42, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ function* foo(a) { a.iwashere = true; return a; }
+ let x = {};
+ let g = foo(x);
+ assertEquals({value: {iwashere: true}, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ let a = 42;
+ function* foo() { return a; }
+ let g = foo();
+ assertEquals({value: 42, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ let a = 40;
+ function* foo(b) { return a + b; }
+ let g = foo(2);
+ assertEquals({value: 42, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ let a = 40;
+ function* foo(b) { a--; b++; return a + b; }
+ let g = foo(2);
+ assertEquals({value: 42, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ let g;
+ function* foo() { Next(g) }
+ g = foo();
+ assertThrows(() => Next(g), TypeError);
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ function* foo() { yield 2; yield 3; yield 4 }
+ g = foo();
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+ assertEquals({value: 4, done: false}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+
+{
+ function* foo() { yield 2; if (true) { yield 3 }; yield 4 }
+ g = foo();
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+ assertEquals({value: 4, done: false}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ function* foo() { yield 2; if (true) { yield 3; yield 4 } }
+ g = foo();
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+ assertEquals({value: 4, done: false}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ function* foo() { yield 2; if (false) { yield 3 }; yield 4 }
+ g = foo();
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 4, done: false}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ function* foo() { yield 2; while (true) { yield 3 }; yield 4 }
+ g = foo();
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+}
+
+{
+ function* foo() { yield 2; (yield 3) + 42; yield 4 }
+ g = foo();
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+ assertEquals({value: 4, done: false}, Next(g));
+}
+
+{
+ function* foo() { yield 2; (do {yield 3}) + 42; yield 4 }
+ g = foo();
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+ assertEquals({value: 4, done: false}, Next(g));
+}
+
+{
+ function* foo() { yield 2; return (yield 3) + 42; yield 4 }
+ g = foo();
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+ assertEquals({value: 42, done: true}, Next(g, 0));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ let x = 42;
+ function* foo() {
+ yield x;
+ for (let x in {a: 1, b: 2}) {
+ let i = 2;
+ yield x;
+ yield i;
+ do {
+ yield i;
+ } while (i-- > 0);
+ }
+ yield x;
+ return 5;
+ }
+ g = foo();
+ assertEquals({value: 42, done: false}, Next(g));
+ assertEquals({value: 'a', done: false}, Next(g));
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 1, done: false}, Next(g));
+ assertEquals({value: 0, done: false}, Next(g));
+ assertEquals({value: 'b', done: false}, Next(g));
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 1, done: false}, Next(g));
+ assertEquals({value: 0, done: false}, Next(g));
+ assertEquals({value: 42, done: false}, Next(g));
+ assertEquals({value: 5, done: true}, Next(g));
+}
+
+{
+ let a = 3;
+ function* foo() {
+ let b = 4;
+ yield 1;
+ { let c = 5; yield 2; yield a; yield b; yield c; }
+ }
+ g = foo();
+ assertEquals({value: 1, done: false}, Next(g));
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 3, done: false}, Next(g));
+ assertEquals({value: 4, done: false}, Next(g));
+ assertEquals({value: 5, done: false}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ function* foo() {
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ yield 42;
+ }
+ g = foo();
+ for (let i = 0; i < 100; ++i) {
+ assertEquals({value: 42, done: false}, i%25 === 0 ? Next(g) : g.next());
+ }
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ function* foo() {
+ for (let i = 0; i < 3; ++i) {
+ let j = 0
+ yield i;
+ do {
+ yield (i + 10);
+ } while (++j < 2);
+ }
+ }
+ g = foo();
+ assertEquals({value: 0, done: false}, Next(g));
+ assertEquals({value: 10, done: false}, Next(g));
+ assertEquals({value: 10, done: false}, Next(g));
+ assertEquals({value: 1, done: false}, Next(g));
+ assertEquals({value: 11, done: false}, Next(g));
+ assertEquals({value: 11, done: false}, Next(g));
+ assertEquals({value: 2, done: false}, Next(g));
+ assertEquals({value: 12, done: false}, Next(g));
+ assertEquals({value: 12, done: false}, Next(g));
+ assertEquals({value: undefined, done: true}, Next(g));
+}
+
+{
+ let foo = function*() {
+ while (true) {
+ if (true || false) yield 42;
+ continue;
+ }
+ }
+ g = foo();
+ assertEquals({value: 42, done: false}, Next(g));
+ assertEquals({value: 42, done: false}, Next(g));
+ assertEquals({value: 42, done: false}, Next(g));
+}
+
+{
+ let foo = function*() {
+ yield* (function*() { yield 42; }());
+ assertUnreachable();
+ }
+ g = foo();
+ assertEquals({value: 42, done: false}, Next(g));
+ assertEquals({value: 23, done: true}, Return(g, 23));
+}
diff --git a/test/mjsunit/harmony/generators.js b/test/mjsunit/harmony/generators.js
index 895a248..eb4e51e 100644
--- a/test/mjsunit/harmony/generators.js
+++ b/test/mjsunit/harmony/generators.js
@@ -648,15 +648,3 @@
assertEquals({value: 42, done: false}, Next(g));
assertEquals({value: 23, done: true}, Return(g, 23));
}
-
-{
- let iterable = {
- [Symbol.iterator]() {
- return { next() { return {} } };
- }
- };
- let foo = function*() { yield* iterable };
- g = foo();
- g.next();
- assertThrows(() => Throw(g), TypeError);
-}
diff --git a/test/mjsunit/harmony/mirror-async-function-promise.js b/test/mjsunit/harmony/mirror-async-function-promise.js
new file mode 100644
index 0000000..966b0ce
--- /dev/null
+++ b/test/mjsunit/harmony/mirror-async-function-promise.js
@@ -0,0 +1,93 @@
+// 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.
+
+// Flags: --expose-debug-as debug --harmony-async-await --allow-natives-syntax
+// Test the mirror object for promises.
+
+var AsyncFunction = (async function() {}).constructor;
+
+function MirrorRefCache(json_refs) {
+ var tmp = eval('(' + json_refs + ')');
+ this.refs_ = [];
+ for (var i = 0; i < tmp.length; i++) {
+ this.refs_[tmp[i].handle] = tmp[i];
+ }
+}
+
+MirrorRefCache.prototype.lookup = function(handle) {
+ return this.refs_[handle];
+}
+
+function testPromiseMirror(promise, status, value) {
+ // Create mirror and JSON representation.
+ var mirror = debug.MakeMirror(promise);
+ var serializer = debug.MakeMirrorSerializer();
+ var json = JSON.stringify(serializer.serializeValue(mirror));
+ var refs = new MirrorRefCache(
+ JSON.stringify(serializer.serializeReferencedObjects()));
+
+ // Check the mirror hierachy.
+ assertTrue(mirror instanceof debug.Mirror);
+ assertTrue(mirror instanceof debug.ValueMirror);
+ assertTrue(mirror instanceof debug.ObjectMirror);
+ assertTrue(mirror instanceof debug.PromiseMirror);
+
+ // Check the mirror properties.
+ assertEquals(status, mirror.status());
+ assertTrue(mirror.isPromise());
+ assertEquals('promise', mirror.type());
+ assertFalse(mirror.isPrimitive());
+ assertEquals("Object", mirror.className());
+ assertEquals("#<Promise>", mirror.toText());
+ assertSame(promise, mirror.value());
+ assertTrue(mirror.promiseValue() instanceof debug.Mirror);
+ assertEquals(value, mirror.promiseValue().value());
+
+ // Parse JSON representation and check.
+ var fromJSON = eval('(' + json + ')');
+ assertEquals('promise', fromJSON.type);
+ assertEquals('Object', fromJSON.className);
+ assertEquals('function', refs.lookup(fromJSON.constructorFunction.ref).type);
+ assertEquals('Promise', refs.lookup(fromJSON.constructorFunction.ref).name);
+ assertEquals(status, fromJSON.status);
+ assertEquals(value, refs.lookup(fromJSON.promiseValue.ref).value);
+}
+
+// Test a number of different promises.
+var resolved = (async function() {})();
+var rejected = (async function() { throw undefined; })();
+var pending = (async function() { await 1; })();
+
+testPromiseMirror(resolved, "resolved", undefined);
+testPromiseMirror(rejected, "rejected", undefined);
+testPromiseMirror(pending, "pending", undefined);
+
+var resolvedv = (async function() { return "resolve"; })();
+var rejectedv = (async function() { return Promise.reject("reject"); })();
+var thrownv = (async function() { throw "throw"; })();
+
+testPromiseMirror(resolvedv, "resolved", 'resolve');
+testPromiseMirror(rejectedv, "rejected", 'reject');
+testPromiseMirror(thrownv, "rejected", 'throw');
+
+// Test internal properties of different promises.
+var m1 = debug.MakeMirror((async function() { return 1; })());
+var ip = m1.internalProperties();
+assertEquals(2, ip.length);
+assertEquals("[[PromiseStatus]]", ip[0].name());
+assertEquals("[[PromiseValue]]", ip[1].name());
+assertEquals("resolved", ip[0].value().value());
+assertEquals(1, ip[1].value().value());
+
+var m2 = debug.MakeMirror((async function() { throw 2; })());
+ip = m2.internalProperties();
+assertEquals("rejected", ip[0].value().value());
+assertEquals(2, ip[1].value().value());
+
+var m3 = debug.MakeMirror((async function() { await 1; })());
+ip = m3.internalProperties();
+assertEquals("pending", ip[0].value().value());
+assertEquals("undefined", typeof(ip[1].value().value()));
+
+%RunMicrotasks();
diff --git a/test/mjsunit/harmony/mirror-async-function.js b/test/mjsunit/harmony/mirror-async-function.js
new file mode 100644
index 0000000..b4ba831
--- /dev/null
+++ b/test/mjsunit/harmony/mirror-async-function.js
@@ -0,0 +1,76 @@
+// 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.
+
+// Flags: --expose-debug-as debug --harmony-async-await --allow-natives-syntax
+// Test the mirror object for functions.
+
+var AsyncFunction = (async function() {}).constructor;
+
+function MirrorRefCache(json_refs) {
+ var tmp = eval('(' + json_refs + ')');
+ this.refs_ = [];
+ for (var i = 0; i < tmp.length; i++) {
+ this.refs_[tmp[i].handle] = tmp[i];
+ }
+}
+
+MirrorRefCache.prototype.lookup = function(handle) {
+ return this.refs_[handle];
+}
+
+function testFunctionMirror(f) {
+ // Create mirror and JSON representation.
+ var mirror = debug.MakeMirror(f);
+ var serializer = debug.MakeMirrorSerializer();
+ var json = JSON.stringify(serializer.serializeValue(mirror));
+ var refs = new MirrorRefCache(
+ JSON.stringify(serializer.serializeReferencedObjects()));
+
+ // Check the mirror hierachy.
+ assertTrue(mirror instanceof debug.Mirror);
+ assertTrue(mirror instanceof debug.ValueMirror);
+ assertTrue(mirror instanceof debug.ObjectMirror);
+ assertTrue(mirror instanceof debug.FunctionMirror);
+
+ // Check the mirror properties.
+ assertTrue(mirror.isFunction());
+ assertEquals('function', mirror.type());
+ assertFalse(mirror.isPrimitive());
+ assertEquals("Function", mirror.className());
+ assertEquals(f.name, mirror.name());
+ assertTrue(mirror.resolved());
+ assertEquals(f.toString(), mirror.source());
+ assertTrue(mirror.constructorFunction() instanceof debug.ObjectMirror);
+ assertTrue(mirror.protoObject() instanceof debug.Mirror);
+ assertTrue(mirror.prototypeObject() instanceof debug.Mirror);
+
+ // Test text representation
+ assertEquals(f.toString(), mirror.toText());
+
+ // Parse JSON representation and check.
+ var fromJSON = eval('(' + json + ')');
+ assertEquals('function', fromJSON.type);
+ assertEquals('Function', fromJSON.className);
+ assertEquals('function', refs.lookup(fromJSON.constructorFunction.ref).type);
+ assertEquals('AsyncFunction',
+ refs.lookup(fromJSON.constructorFunction.ref).name);
+ assertTrue(fromJSON.resolved);
+ assertEquals(f.name, fromJSON.name);
+ assertEquals(f.toString(), fromJSON.source);
+
+ // Check the formatted text (regress 1142074).
+ assertEquals(f.toString(), fromJSON.text);
+}
+
+
+// Test a number of different functions.
+testFunctionMirror(async function(){});
+testFunctionMirror(AsyncFunction());
+testFunctionMirror(new AsyncFunction());
+testFunctionMirror(async() => {});
+testFunctionMirror(async function a(){return 1;});
+testFunctionMirror(({ async foo() {} }).foo);
+testFunctionMirror((async function(){}).bind({}), "Object");
+
+%RunMicrotasks();
diff --git a/test/mjsunit/harmony/regexp-change-exec.js b/test/mjsunit/harmony/regexp-change-exec.js
index 4c9757e..ff84506 100644
--- a/test/mjsunit/harmony/regexp-change-exec.js
+++ b/test/mjsunit/harmony/regexp-change-exec.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-exec
-
class MyError extends Error { }
RegExp.prototype.exec = () => { throw new MyError() };
assertThrows(() => "foo".match(/bar/), MyError);
diff --git a/test/mjsunit/harmony/regexp-named-captures.js b/test/mjsunit/harmony/regexp-named-captures.js
new file mode 100644
index 0000000..ced8e4b
--- /dev/null
+++ b/test/mjsunit/harmony/regexp-named-captures.js
@@ -0,0 +1,76 @@
+// 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.
+
+// Flags: --harmony-regexp-named-captures
+
+// Malformed named captures.
+assertThrows("/(?<>a)/u"); // Empty name.
+assertThrows("/(?<aa)/u"); // Unterminated name.
+assertThrows("/(?<42a>a)/u"); // Name starting with digits.
+assertThrows("/(?<:a>a)/u"); // Name starting with invalid char.
+assertThrows("/(?<a:>a)/u"); // Name containing with invalid char.
+assertThrows("/(?<a>a)(?<a>a)/u"); // Duplicate name.
+assertThrows("/(?<a>a)(?<b>b)(?<a>a)/u"); // Duplicate name.
+assertThrows("/\\k<a>/u"); // Invalid reference.
+assertThrows("/(?<a>a)\\k<ab>/u"); // Invalid reference.
+assertThrows("/(?<ab>a)\\k<a>/u"); // Invalid reference.
+assertThrows("/\\k<a>(?<ab>a)/u"); // Invalid reference.
+
+// Fallback behavior in non-unicode mode.
+assertThrows("/(?<>a)/");
+assertThrows("/(?<aa)/");
+assertThrows("/(?<42a>a)/");
+assertThrows("/(?<:a>a)/");
+assertThrows("/(?<a:>a)/");
+assertThrows("/(?<a>a)(?<a>a)/");
+assertThrows("/(?<a>a)(?<b>b)(?<a>a)/");
+assertThrows("/(?<a>a)\\k<ab>/");
+assertThrows("/(?<ab>a)\\k<a>/");
+
+assertEquals(["k<a>"], "xxxk<a>xxx".match(/\k<a>/));
+assertEquals(["k<a"], "xxxk<a>xxx".match(/\k<a/));
+
+// Basic named groups.
+assertEquals(["a", "a"], "bab".match(/(?<a>a)/u));
+assertEquals(["a", "a"], "bab".match(/(?<a42>a)/u));
+assertEquals(["a", "a"], "bab".match(/(?<_>a)/u));
+assertEquals(["a", "a"], "bab".match(/(?<$>a)/u));
+assertEquals(["bab", "a"], "bab".match(/.(?<$>a)./u));
+assertEquals(["bab", "a", "b"], "bab".match(/.(?<a>a)(.)/u));
+assertEquals(["bab", "a", "b"], "bab".match(/.(?<a>a)(?<b>.)/u));
+assertEquals(["bab", "ab"], "bab".match(/.(?<a>\w\w)/u));
+assertEquals(["bab", "bab"], "bab".match(/(?<a>\w\w\w)/u));
+assertEquals(["bab", "ba", "b"], "bab".match(/(?<a>\w\w)(?<b>\w)/u));
+
+assertEquals("bab".match(/(a)/u), "bab".match(/(?<a>a)/u));
+assertEquals("bab".match(/(a)/u), "bab".match(/(?<a42>a)/u));
+assertEquals("bab".match(/(a)/u), "bab".match(/(?<_>a)/u));
+assertEquals("bab".match(/(a)/u), "bab".match(/(?<$>a)/u));
+assertEquals("bab".match(/.(a)./u), "bab".match(/.(?<$>a)./u));
+assertEquals("bab".match(/.(a)(.)/u), "bab".match(/.(?<a>a)(.)/u));
+assertEquals("bab".match(/.(a)(.)/u), "bab".match(/.(?<a>a)(?<b>.)/u));
+assertEquals("bab".match(/.(\w\w)/u), "bab".match(/.(?<a>\w\w)/u));
+assertEquals("bab".match(/(\w\w\w)/u), "bab".match(/(?<a>\w\w\w)/u));
+assertEquals("bab".match(/(\w\w)(\w)/u), "bab".match(/(?<a>\w\w)(?<b>\w)/u));
+
+assertEquals(["bab", "b"], "bab".match(/(?<b>b).\1/u));
+assertEquals(["baba", "b", "a"], "baba".match(/(.)(?<a>a)\1\2/u));
+assertEquals(["baba", "b", "a", "b", "a"],
+ "baba".match(/(.)(?<a>a)(?<b>\1)(\2)/u));
+assertEquals(["<a", "<"], "<a".match(/(?<lt><)a/u));
+assertEquals([">a", ">"], ">a".match(/(?<gt>>)a/u));
+
+// Named references.
+assertEquals(["bab", "b"], "bab".match(/(?<b>.).\k<b>/u));
+assertNull("baa".match(/(?<b>.).\k<b>/u));
+
+// Nested groups.
+assertEquals(["bab", "bab", "ab", "b"], "bab".match(/(?<a>.(?<b>.(?<c>.)))/u));
+
+// Reference inside group.
+assertEquals(["bab", "b"], "bab".match(/(?<a>\k<a>\w)../u));
+
+// Reference before group.
+assertEquals(["bab", "b"], "bab".match(/\k<a>(?<a>b)\w\k<a>/u));
+assertEquals(["bab", "b", "a"], "bab".match(/(?<b>b)\k<a>(?<a>a)\k<b>/u));
diff --git a/test/mjsunit/harmony/regexp-no-change-exec.js b/test/mjsunit/harmony/regexp-no-change-exec.js
deleted file mode 100644
index 30b5050..0000000
--- a/test/mjsunit/harmony/regexp-no-change-exec.js
+++ /dev/null
@@ -1,9 +0,0 @@
-// 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.
-
-// Flags: --no-harmony-regexp-exec
-
-class MyError extends Error { }
-RegExp.prototype.exec = () => { throw new MyError() };
-assertEquals(null, "foo".match(/bar/));
diff --git a/test/mjsunit/harmony/regexp-property-binary.js b/test/mjsunit/harmony/regexp-property-binary.js
index d0894b7..c0b4426 100644
--- a/test/mjsunit/harmony/regexp-property-binary.js
+++ b/test/mjsunit/harmony/regexp-property-binary.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-property --harmony-unicode-regexps
+// Flags: --harmony-regexp-property
function t(re, s) { assertTrue(re.test(s)); }
function f(re, s) { assertFalse(re.test(s)); }
diff --git a/test/mjsunit/harmony/regexp-property-blocks.js b/test/mjsunit/harmony/regexp-property-blocks.js
index f41c06e..de3fd1e 100644
--- a/test/mjsunit/harmony/regexp-property-blocks.js
+++ b/test/mjsunit/harmony/regexp-property-blocks.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-property --harmony-unicode-regexps
+// Flags: --harmony-regexp-property
function t(re, s) { assertTrue(re.test(s)); }
function f(re, s) { assertFalse(re.test(s)); }
diff --git a/test/mjsunit/harmony/regexp-property-char-class.js b/test/mjsunit/harmony/regexp-property-char-class.js
index 6162012..c70e826 100644
--- a/test/mjsunit/harmony/regexp-property-char-class.js
+++ b/test/mjsunit/harmony/regexp-property-char-class.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps --harmony-regexp-property
+// Flags: --harmony-regexp-property
assertThrows("/[\\p]/u");
assertThrows("/[\\p{garbage}]/u");
diff --git a/test/mjsunit/harmony/regexp-property-disabled.js b/test/mjsunit/harmony/regexp-property-disabled.js
index 7a3158c..f471ef4 100644
--- a/test/mjsunit/harmony/regexp-property-disabled.js
+++ b/test/mjsunit/harmony/regexp-property-disabled.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps --no-harmony-regexp-property
+// Flags: --no-harmony-regexp-property
function test(source, message) {
try {
diff --git a/test/mjsunit/harmony/regexp-property-enumerated.js b/test/mjsunit/harmony/regexp-property-enumerated.js
index e4a81a4..dba8397 100644
--- a/test/mjsunit/harmony/regexp-property-enumerated.js
+++ b/test/mjsunit/harmony/regexp-property-enumerated.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-property --harmony-unicode-regexps
+// Flags: --harmony-regexp-property
function t(re, s) { assertTrue(re.test(s)); }
function f(re, s) { assertFalse(re.test(s)); }
diff --git a/test/mjsunit/harmony/regexp-property-exact-match.js b/test/mjsunit/harmony/regexp-property-exact-match.js
index fe233f2..0d1f704 100644
--- a/test/mjsunit/harmony/regexp-property-exact-match.js
+++ b/test/mjsunit/harmony/regexp-property-exact-match.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-property --harmony-unicode-regexps
+// Flags: --harmony-regexp-property
assertThrows("/\\p{In CJK}/u");
assertThrows("/\\p{InCJKUnifiedIdeographs}/u");
@@ -15,7 +15,7 @@
assertThrows("/\\p{InCyrillicSupplementary}/u");
assertThrows("/\\p{InCyrillic_supplementary}/u");
-assertDoesNotThrow("/\\pC/u");
+assertDoesNotThrow("/\\p{C}/u");
assertDoesNotThrow("/\\p{Other}/u");
assertDoesNotThrow("/\\p{Cc}/u");
assertDoesNotThrow("/\\p{Control}/u");
diff --git a/test/mjsunit/harmony/regexp-property-general-category.js b/test/mjsunit/harmony/regexp-property-general-category.js
index e2015ad..e4fb8b5 100644
--- a/test/mjsunit/harmony/regexp-property-general-category.js
+++ b/test/mjsunit/harmony/regexp-property-general-category.js
@@ -2,16 +2,20 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-property --harmony-unicode-regexps
+// Flags: --harmony-regexp-property
assertThrows("/\\p/u");
assertThrows("/\\p{garbage}/u");
assertThrows("/\\p{}/u");
assertThrows("/\\p{/u");
assertThrows("/\\p}/u");
-assertThrows("/\p{Math}/u");
-assertThrows("/\p{Bidi_M}/u");
-assertThrows("/\p{Hex}/u");
+assertThrows("/\\pL/u");
+assertThrows("/\\P/u");
+assertThrows("/\\P{garbage}/u");
+assertThrows("/\\P{}/u");
+assertThrows("/\\P{/u");
+assertThrows("/\\P}/u");
+assertThrows("/\\PL/u");
assertTrue(/\p{Ll}/u.test("a"));
assertFalse(/\P{Ll}/u.test("a"));
@@ -26,10 +30,10 @@
assertTrue(/\p{Ll}/iu.test("\u{118D4}"));
assertTrue(/\p{Ll}/iu.test("A"));
assertTrue(/\p{Ll}/iu.test("\u{118B4}"));
-assertFalse(/\P{Ll}/iu.test("a"));
-assertFalse(/\P{Ll}/iu.test("\u{118D4}"));
-assertFalse(/\P{Ll}/iu.test("A"));
-assertFalse(/\P{Ll}/iu.test("\u{118B4}"));
+assertTrue(/\P{Ll}/iu.test("a"));
+assertTrue(/\P{Ll}/iu.test("\u{118D4}"));
+assertTrue(/\P{Ll}/iu.test("A"));
+assertTrue(/\P{Ll}/iu.test("\u{118B4}"));
assertTrue(/\p{Lu}/u.test("A"));
assertFalse(/\P{Lu}/u.test("A"));
@@ -44,22 +48,16 @@
assertTrue(/\p{Lu}/iu.test("\u{118D4}"));
assertTrue(/\p{Lu}/iu.test("A"));
assertTrue(/\p{Lu}/iu.test("\u{118B4}"));
-assertFalse(/\P{Lu}/iu.test("a"));
-assertFalse(/\P{Lu}/iu.test("\u{118D4}"));
-assertFalse(/\P{Lu}/iu.test("A"));
-assertFalse(/\P{Lu}/iu.test("\u{118B4}"));
+assertTrue(/\P{Lu}/iu.test("a"));
+assertTrue(/\P{Lu}/iu.test("\u{118D4}"));
+assertTrue(/\P{Lu}/iu.test("A"));
+assertTrue(/\P{Lu}/iu.test("\u{118B4}"));
assertTrue(/\p{Sm}/u.test("+"));
assertFalse(/\P{Sm}/u.test("+"));
assertTrue(/\p{Sm}/u.test("\u{1D6C1}"));
assertFalse(/\P{Sm}/u.test("\u{1D6C1}"));
-assertTrue(/\pL/u.test("a"));
-assertFalse(/\PL/u.test("a"));
-assertFalse(/\pL/u.test("1"));
-assertTrue(/\PL/u.test("1"));
-assertTrue(/\pL/u.test("\u1FAB"));
-assertFalse(/\PL/u.test("\u1FAB"));
assertFalse(/\p{L}/u.test("\uA6EE"));
assertTrue(/\P{L}/u.test("\uA6EE"));
diff --git a/test/mjsunit/harmony/regexp-property-lu-ui.js b/test/mjsunit/harmony/regexp-property-lu-ui.js
new file mode 100644
index 0000000..115e064
--- /dev/null
+++ b/test/mjsunit/harmony/regexp-property-lu-ui.js
@@ -0,0 +1,13 @@
+// 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.
+
+// Flags: --harmony-regexp-property
+
+const regexp = /\P{Lu}/ui;
+const regexpu = /[\0-@\[-\xBF\xD7\xDF-\xFF\u0101\u0103\u0105\u0107\u0109\u010B\u010D\u010F\u0111\u0113\u0115\u0117\u0119\u011B\u011D\u011F\u0121\u0123\u0125\u0127\u0129\u012B\u012D\u012F\u0131\u0133\u0135\u0137\u0138\u013A\u013C\u013E\u0140\u0142\u0144\u0146\u0148\u0149\u014B\u014D\u014F\u0151\u0153\u0155\u0157\u0159\u015B\u015D\u015F\u0161\u0163\u0165\u0167\u0169\u016B\u016D\u016F\u0171\u0173\u0175\u0177\u017A\u017C\u017E-\u0180\u0183\u0185\u0188\u018C\u018D\u0192\u0195\u0199-\u019B\u019E\u01A1\u01A3\u01A5\u01A8\u01AA\u01AB\u01AD\u01B0\u01B4\u01B6\u01B9-\u01BB\u01BD-\u01C3\u01C5\u01C6\u01C8\u01C9\u01CB\u01CC\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC\u01DD\u01DF\u01E1\u01E3\u01E5\u01E7\u01E9\u01EB\u01ED\u01EF\u01F0\u01F2\u01F3\u01F5\u01F9\u01FB\u01FD\u01FF\u0201\u0203\u0205\u0207\u0209\u020B\u020D\u020F\u0211\u0213\u0215\u0217\u0219\u021B\u021D\u021F\u0221\u0223\u0225\u0227\u0229\u022B\u022D\u022F\u0231\u0233-\u0239\u023C\u023F\u0240\u0242\u0247\u0249\u024B\u024D\u024F-\u036F\u0371\u0373-\u0375\u0377-\u037E\u0380-\u0385\u0387\u038B\u038D\u0390\u03A2\u03AC-\u03CE\u03D0\u03D1\u03D5-\u03D7\u03D9\u03DB\u03DD\u03DF\u03E1\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF-\u03F3\u03F5\u03F6\u03F8\u03FB\u03FC\u0430-\u045F\u0461\u0463\u0465\u0467\u0469\u046B\u046D\u046F\u0471\u0473\u0475\u0477\u0479\u047B\u047D\u047F\u0481-\u0489\u048B\u048D\u048F\u0491\u0493\u0495\u0497\u0499\u049B\u049D\u049F\u04A1\u04A3\u04A5\u04A7\u04A9\u04AB\u04AD\u04AF\u04B1\u04B3\u04B5\u04B7\u04B9\u04BB\u04BD\u04BF\u04C2\u04C4\u04C6\u04C8\u04CA\u04CC\u04CE\u04CF\u04D1\u04D3\u04D5\u04D7\u04D9\u04DB\u04DD\u04DF\u04E1\u04E3\u04E5\u04E7\u04E9\u04EB\u04ED\u04EF\u04F1\u04F3\u04F5\u04F7\u04F9\u04FB\u04FD\u04FF\u0501\u0503\u0505\u0507\u0509\u050B\u050D\u050F\u0511\u0513\u0515\u0517\u0519\u051B\u051D\u051F\u0521\u0523\u0525\u0527\u0529\u052B\u052D\u052F\u0530\u0557-\u109F\u10C6\u10C8-\u10CC\u10CE-\u139F\u13F6-\u1DFF\u1E01\u1E03\u1E05\u1E07\u1E09\u1E0B\u1E0D\u1E0F\u1E11\u1E13\u1E15\u1E17\u1E19\u1E1B\u1E1D\u1E1F\u1E21\u1E23\u1E25\u1E27\u1E29\u1E2B\u1E2D\u1E2F\u1E31\u1E33\u1E35\u1E37\u1E39\u1E3B\u1E3D\u1E3F\u1E41\u1E43\u1E45\u1E47\u1E49\u1E4B\u1E4D\u1E4F\u1E51\u1E53\u1E55\u1E57\u1E59\u1E5B\u1E5D\u1E5F\u1E61\u1E63\u1E65\u1E67\u1E69\u1E6B\u1E6D\u1E6F\u1E71\u1E73\u1E75\u1E77\u1E79\u1E7B\u1E7D\u1E7F\u1E81\u1E83\u1E85\u1E87\u1E89\u1E8B\u1E8D\u1E8F\u1E91\u1E93\u1E95-\u1E9D\u1E9F\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\u1EB9\u1EBB\u1EBD\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1EC9\u1ECB\u1ECD\u1ECF\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3\u1EE5\u1EE7\u1EE9\u1EEB\u1EED\u1EEF\u1EF1\u1EF3\u1EF5\u1EF7\u1EF9\u1EFB\u1EFD\u1EFF-\u1F07\u1F10-\u1F17\u1F1E-\u1F27\u1F30-\u1F37\u1F40-\u1F47\u1F4E-\u1F58\u1F5A\u1F5C\u1F5E\u1F60-\u1F67\u1F70-\u1FB7\u1FBC-\u1FC7\u1FCC-\u1FD7\u1FDC-\u1FE7\u1FED-\u1FF7\u1FFC-\u2101\u2103-\u2106\u2108-\u210A\u210E\u210F\u2113\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u212F\u2134-\u213D\u2140-\u2144\u2146-\u2182\u2184-\u2BFF\u2C2F-\u2C5F\u2C61\u2C65\u2C66\u2C68\u2C6A\u2C6C\u2C71\u2C73\u2C74\u2C76-\u2C7D\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8B\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CB3\u2CB5\u2CB7\u2CB9\u2CBB\u2CBD\u2CBF\u2CC1\u2CC3\u2CC5\u2CC7\u2CC9\u2CCB\u2CCD\u2CCF\u2CD1\u2CD3\u2CD5\u2CD7\u2CD9\u2CDB\u2CDD\u2CDF\u2CE1\u2CE3-\u2CEA\u2CEC\u2CEE-\u2CF1\u2CF3-\uA63F\uA641\uA643\uA645\uA647\uA649\uA64B\uA64D\uA64F\uA651\uA653\uA655\uA657\uA659\uA65B\uA65D\uA65F\uA661\uA663\uA665\uA667\uA669\uA66B\uA66D-\uA67F\uA681\uA683\uA685\uA687\uA689\uA68B\uA68D\uA68F\uA691\uA693\uA695\uA697\uA699\uA69B-\uA721\uA723\uA725\uA727\uA729\uA72B\uA72D\uA72F-\uA731\uA733\uA735\uA737\uA739\uA73B\uA73D\uA73F\uA741\uA743\uA745\uA747\uA749\uA74B\uA74D\uA74F\uA751\uA753\uA755\uA757\uA759\uA75B\uA75D\uA75F\uA761\uA763\uA765\uA767\uA769\uA76B\uA76D\uA76F-\uA778\uA77A\uA77C\uA77F\uA781\uA783\uA785\uA787-\uA78A\uA78C\uA78E\uA78F\uA791\uA793-\uA795\uA797\uA799\uA79B\uA79D\uA79F\uA7A1\uA7A3\uA7A5\uA7A7\uA7A9\uA7AE\uA7AF\uA7B5\uA7B7-\uFF20\uFF3B-\u{103FF}\u{10428}-\u{10C7F}\u{10CB3}-\u{1189F}\u{118C0}-\u{1D3FF}\u{1D41A}-\u{1D433}\u{1D44E}-\u{1D467}\u{1D482}-\u{1D49B}\u{1D49D}\u{1D4A0}\u{1D4A1}\u{1D4A3}\u{1D4A4}\u{1D4A7}\u{1D4A8}\u{1D4AD}\u{1D4B6}-\u{1D4CF}\u{1D4EA}-\u{1D503}\u{1D506}\u{1D50B}\u{1D50C}\u{1D515}\u{1D51D}-\u{1D537}\u{1D53A}\u{1D53F}\u{1D545}\u{1D547}-\u{1D549}\u{1D551}-\u{1D56B}\u{1D586}-\u{1D59F}\u{1D5BA}-\u{1D5D3}\u{1D5EE}-\u{1D607}\u{1D622}-\u{1D63B}\u{1D656}-\u{1D66F}\u{1D68A}-\u{1D6A7}\u{1D6C1}-\u{1D6E1}\u{1D6FB}-\u{1D71B}\u{1D735}-\u{1D755}\u{1D76F}-\u{1D78F}\u{1D7A9}-\u{1D7C9}\u{1D7CB}-\u{10FFFF}]/ui;
+
+for (let codePoint = 0; codePoint <= 0x10FFFF; codePoint++) {
+ const string = String.fromCodePoint(codePoint);
+ assertEquals(regexp.test(string), regexpu.test(string));
+}
diff --git a/test/mjsunit/harmony/regexp-property-scripts.js b/test/mjsunit/harmony/regexp-property-scripts.js
index ec2b11d..565a59a 100644
--- a/test/mjsunit/harmony/regexp-property-scripts.js
+++ b/test/mjsunit/harmony/regexp-property-scripts.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-regexp-property --harmony-unicode-regexps
+// Flags: --harmony-regexp-property
function t(re, s) { assertTrue(re.test(s)); }
function f(re, s) { assertFalse(re.test(s)); }
diff --git a/test/mjsunit/harmony/regexp-property-special.js b/test/mjsunit/harmony/regexp-property-special.js
new file mode 100644
index 0000000..204b77f
--- /dev/null
+++ b/test/mjsunit/harmony/regexp-property-special.js
@@ -0,0 +1,51 @@
+// 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.
+
+// Flags: --harmony-regexp-property
+
+function t(re, s) { assertTrue(re.test(s)); }
+function f(re, s) { assertFalse(re.test(s)); }
+
+t(/\p{ASCII}+/u, "abc123");
+f(/\p{ASCII}+/u, "ⓐⓑⓒ①②③");
+f(/\p{ASCII}+/u, "🄰🄱🄲①②③");
+f(/\P{ASCII}+/u, "abcd123");
+t(/\P{ASCII}+/u, "ⓐⓑⓒ①②③");
+t(/\P{ASCII}+/u, "🄰🄱🄲①②③");
+
+f(/[^\p{ASCII}]+/u, "abc123");
+f(/[\p{ASCII}]+/u, "ⓐⓑⓒ①②③");
+f(/[\p{ASCII}]+/u, "🄰🄱🄲①②③");
+t(/[^\P{ASCII}]+/u, "abcd123");
+t(/[\P{ASCII}]+/u, "ⓐⓑⓒ①②③");
+f(/[^\P{ASCII}]+/u, "🄰🄱🄲①②③");
+
+t(/\p{Any}+/u, "🄰🄱🄲①②③");
+
+assertEquals(["\ud800"], /\p{Any}/u.exec("\ud800\ud801"));
+assertEquals(["\udc00"], /\p{Any}/u.exec("\udc00\udc01"));
+assertEquals(["\ud800\udc01"], /\p{Any}/u.exec("\ud800\udc01"));
+assertEquals(["\udc01"], /\p{Any}/u.exec("\udc01"));
+
+f(/\P{Any}+/u, "123");
+f(/[\P{Any}]+/u, "123");
+t(/[\P{Any}\d]+/u, "123");
+t(/[^\P{Any}]+/u, "123");
+
+t(/\p{Assigned}+/u, "123");
+t(/\p{Assigned}+/u, "🄰🄱🄲");
+f(/\p{Assigned}+/u, "\ufdd0");
+f(/\p{Assigned}+/u, "\u{fffff}");
+
+f(/\P{Assigned}+/u, "123");
+f(/\P{Assigned}+/u, "🄰🄱🄲");
+t(/\P{Assigned}+/u, "\ufdd0");
+t(/\P{Assigned}+/u, "\u{fffff}");
+f(/\P{Assigned}/u, "");
+
+t(/[^\P{Assigned}]+/u, "123");
+f(/[\P{Assigned}]+/u, "🄰🄱🄲");
+f(/[^\P{Assigned}]+/u, "\ufdd0");
+t(/[\P{Assigned}]+/u, "\u{fffff}");
+f(/[\P{Assigned}]/u, "");
diff --git a/test/mjsunit/harmony/regress/regress-618603.js b/test/mjsunit/harmony/regress/regress-618603.js
new file mode 100644
index 0000000..7b23ef4
--- /dev/null
+++ b/test/mjsunit/harmony/regress/regress-618603.js
@@ -0,0 +1,14 @@
+// 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.
+
+// Flags: --harmony-async-await --ignition-generators
+
+try {
+} catch(e) {; }
+function __f_7(expected, run) {
+ var __v_10 = run();
+};
+__f_7("[1,2,3]", () => (function() {
+ return (async () => {[...await arguments] })();
+ })());
diff --git a/test/mjsunit/harmony/regress/regress-crbug-621111.js b/test/mjsunit/harmony/regress/regress-crbug-621111.js
new file mode 100644
index 0000000..58a0d5c
--- /dev/null
+++ b/test/mjsunit/harmony/regress/regress-crbug-621111.js
@@ -0,0 +1,6 @@
+// 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.
+
+(y = 1[1, [...[]]]) => 1; // will core dump, if not fixed
+(y = 1[1, [...[]]]) => {}; // will core dump, if not fixed
diff --git a/test/mjsunit/harmony/regress/regress-crbug-621496.js b/test/mjsunit/harmony/regress/regress-crbug-621496.js
new file mode 100644
index 0000000..4db7a95
--- /dev/null
+++ b/test/mjsunit/harmony/regress/regress-crbug-621496.js
@@ -0,0 +1,7 @@
+// 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.
+
+(function testIllegalSpreadAsSingleArrowParameter() {
+ assertThrows("(...[42]) => 42)", SyntaxError) // will core dump, if not fixed
+})();
diff --git a/test/mjsunit/harmony/simd.js b/test/mjsunit/harmony/simd.js
index 1868050..a3d4615 100644
--- a/test/mjsunit/harmony/simd.js
+++ b/test/mjsunit/harmony/simd.js
@@ -622,7 +622,9 @@
function TestStringify(expected, input) {
assertEquals(expected, JSON.stringify(input));
- assertEquals(expected, JSON.stringify(input, null, 0));
+ assertEquals(expected, JSON.stringify(input, (key, value) => value));
+ assertEquals(JSON.stringify(input, null, "="),
+ JSON.stringify(input, (key, value) => value, "="));
}
TestStringify(undefined, SIMD.Float32x4(1, 2, 3, 4));
diff --git a/test/mjsunit/harmony/sloppy-legacy-duplicate-generators.js b/test/mjsunit/harmony/sloppy-legacy-duplicate-generators.js
new file mode 100644
index 0000000..1fde475
--- /dev/null
+++ b/test/mjsunit/harmony/sloppy-legacy-duplicate-generators.js
@@ -0,0 +1,60 @@
+// 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.
+
+// Flags: --no-harmony-restrictive-generators
+
+// In legacy mode, generators get sloppy-mode block-scoped function hoisting
+
+// Hoisting to the global scope
+
+{
+ function* foo() {}
+ assertEquals('function', typeof foo);
+}
+//assertEquals('function', typeof foo);
+
+// Hoisting within a function scope
+(function() {
+ { function* bar() {} }
+ assertEquals('function', typeof bar);
+})();
+
+// Lexical shadowing allowed; hoisting happens
+(function() {
+ function* x() { yield 1; }
+ { function* x() { yield 2 } }
+ assertEquals(2, x().next().value);
+})();
+
+// Duplicates allowed
+(function() {
+ function* y() { yield 1; }
+ function* y() { yield 2 }
+ assertEquals(2, y().next().value);
+})();
+
+// Functions and generators may duplicate each other
+(function() {
+ function* z() { yield 1; }
+ function z() { return 2 }
+ assertEquals(2, z());
+
+ function a() { return 1; }
+ function* a() { yield 2 }
+ assertEquals(2, a().next().value);
+})();
+
+// In strict mode, none of this happens
+
+(function() {
+ 'use strict';
+
+ { function* bar() {} }
+ assertEquals('undefined', typeof bar);
+
+ // Lexical shadowing allowed; hoisting happens
+ function* x() { yield 1; }
+ { function* x() { yield 2 } }
+ assertEquals(1, x().next().value);
+})();
diff --git a/test/mjsunit/harmony/sloppy-no-duplicate-async.js b/test/mjsunit/harmony/sloppy-no-duplicate-async.js
new file mode 100644
index 0000000..97411c0
--- /dev/null
+++ b/test/mjsunit/harmony/sloppy-no-duplicate-async.js
@@ -0,0 +1,30 @@
+// 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.
+
+// Flags: --harmony-async-await
+
+// Async functions don't get sloppy-mode block-scoped function hoisting
+
+// No hoisting to the global scope
+
+{
+ async function foo() {}
+ assertEquals('function', typeof foo);
+}
+assertEquals('undefined', typeof foo);
+
+// No hoisting within a function scope
+(function() {
+ { async function bar() {} }
+ assertEquals('undefined', typeof bar);
+})();
+
+// Lexical shadowing allowed, no hoisting
+(function() {
+ var y;
+ async function x() { y = 1; }
+ { async function x() { y = 2; } }
+ x();
+ assertEquals(1, y);
+})();
diff --git a/test/mjsunit/harmony/sloppy-no-duplicate-generators.js b/test/mjsunit/harmony/sloppy-no-duplicate-generators.js
new file mode 100644
index 0000000..de2e461
--- /dev/null
+++ b/test/mjsunit/harmony/sloppy-no-duplicate-generators.js
@@ -0,0 +1,28 @@
+// 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.
+
+// Flags: --harmony-restrictive-generators
+
+// Generators don't get sloppy-mode block-scoped function hoisting
+
+// No hoisting to the global scope
+
+{
+ function* foo() {}
+ assertEquals('function', typeof foo);
+}
+assertEquals('undefined', typeof foo);
+
+// No hoisting within a function scope
+(function() {
+ { function* bar() {} }
+ assertEquals('undefined', typeof bar);
+})();
+
+// Lexical shadowing allowed, no hoisting
+(function() {
+ function* x() { yield 1; }
+ { function* x() { yield 2 } }
+ assertEquals(1, x().next().value);
+})();
diff --git a/test/mjsunit/ignition/elided-instruction-no-ignition.js b/test/mjsunit/ignition/elided-instruction-no-ignition.js
deleted file mode 100644
index 50ad528..0000000
--- a/test/mjsunit/ignition/elided-instruction-no-ignition.js
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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.
-
-// Flags: --no-ignition --expose-debug-as debug
-
-Debug = debug.Debug
-
-var exception = null;
-var break_count = 0;
-
-function listener(event, exec_state, event_data, data) {
- if (event != Debug.DebugEvent.Break) return;
- try {
- print(event_data.sourceLineText());
- var column = event_data.sourceColumn();
- assertTrue(event_data.sourceLineText().indexOf(
- `Break ${break_count++}. ${column}.`) > 0);
- exec_state.prepareStep(Debug.StepAction.StepIn);
- } catch (e) {
- print(e + e.stack);
- exception = e;
- }
-};
-
-function f() {
- var a = 1; // Break 2. 10.
- return a; // Break 3. 2.
-} // Break 4. 0.
-
-Debug.setListener(listener);
-debugger; // Break 0. 0.
-f(); // Break 1. 0.
-Debug.setListener(null); // Break 5. 0.
-
-assertNull(exception);
-assertEquals(6, break_count);
diff --git a/test/mjsunit/ignition/elided-instruction.js b/test/mjsunit/ignition/elided-instruction.js
index a047f41..d31150b 100644
--- a/test/mjsunit/ignition/elided-instruction.js
+++ b/test/mjsunit/ignition/elided-instruction.js
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --ignition --expose-debug-as debug
+// Flags: --expose-debug-as debug
Debug = debug.Debug
@@ -25,17 +25,13 @@
function f() {
var a = 1; // Break 2. 10.
- // This return statement emits no bytecode instruction for the evaluation of
- // the to-be-returned expression. Therefore we cannot set a break location
- // before the statement and a second break location immediately before
- // returning to the caller.
- return a;
-} // Break 3. 0.
+ return a; // Break 3. 2.
+} // Break 4. 0.
Debug.setListener(listener);
debugger; // Break 0. 0.
f(); // Break 1. 0.
-Debug.setListener(null); // Break 4. 0.
+Debug.setListener(null); // Break 5. 0.
assertNull(exception);
-assertEquals(5, break_count);
+assertEquals(6, break_count);
diff --git a/test/mjsunit/ignition/regress-612386-smi-to-double-transition.js b/test/mjsunit/ignition/regress-612386-smi-to-double-transition.js
new file mode 100644
index 0000000..275f7d6
--- /dev/null
+++ b/test/mjsunit/ignition/regress-612386-smi-to-double-transition.js
@@ -0,0 +1,29 @@
+// 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.
+
+// Flags: --no-inline-new
+
+function keyed_store(obj, key, value) {
+ obj[key] = value;
+}
+
+function foo() {
+ obj = {};
+ obj.smi = 1;
+ obj.dbl = 1.5;
+ obj.obj = {a:1};
+
+ // Transition keyed store IC to polymorphic.
+ keyed_store(obj, "smi", 100);
+ keyed_store(obj, "dbl", 100);
+ keyed_store(obj, "obj", 100);
+
+ // Now call with a FAST_SMI_ELEMENTS object.
+ var smi_array = [5, 1, 1];
+ keyed_store(smi_array, 1, 6);
+ // Transition from FAST_SMI_ELEMENTS to FAST_DOUBLE_ELEMENTS.
+ keyed_store(smi_array, 2, 1.2);
+}
+
+foo();
diff --git a/test/mjsunit/ignition/regress-616064.js b/test/mjsunit/ignition/regress-616064.js
new file mode 100644
index 0000000..06de873
--- /dev/null
+++ b/test/mjsunit/ignition/regress-616064.js
@@ -0,0 +1,26 @@
+// 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.
+
+// Flags: --ignition
+
+function foo() {
+ if (this.Worker) {
+ function __f_0() { this.s = a; }
+ function __f_1() {
+ this.l = __f_0;
+ }
+
+ with ( 'source' , Object ) throw function __f_0(__f_0) {
+ return Worker.__f_0(-2147483648, __f_0);
+ };
+
+ var __v_9 = new Worker('');
+ __f_1 = {s: Math.s, __f_1: true};
+ }
+}
+
+try {
+ foo();
+} catch(e) {
+}
diff --git a/test/mjsunit/json-replacer-order.js b/test/mjsunit/json-replacer-order.js
index 8cb6441..19b69bf 100644
--- a/test/mjsunit/json-replacer-order.js
+++ b/test/mjsunit/json-replacer-order.js
@@ -20,7 +20,6 @@
});
JSON.stringify('', replacer, space);
-
assertEquals(2, log.length);
assertEquals('get 0', log[0]);
assertEquals('toString', log[1]);
diff --git a/test/mjsunit/json-stringify-holder.js b/test/mjsunit/json-stringify-holder.js
new file mode 100644
index 0000000..2f06d77
--- /dev/null
+++ b/test/mjsunit/json-stringify-holder.js
@@ -0,0 +1,104 @@
+// 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.
+
+(function testBasic() {
+ var stack = [];
+ var object = {a: false};
+ var replaced = {a: false, replaced: true};
+
+ function replacer(key, value) {
+ stack.push({ holder: this, key, value });
+ if (stack.length === 1) return replaced;
+ if (key === "a") return true;
+ return value;
+ }
+
+ assertEquals(`{"a":true,"replaced":true}`, JSON.stringify(object, replacer));
+
+ assertEquals([
+ {
+ holder: { "": { a: false } },
+ key: "",
+ value: { a: false }
+ },
+ {
+ holder: { a: false, replaced: true },
+ key: "a",
+ value: false
+ },
+ {
+ holder: { a: false, replaced: true },
+ key: "replaced",
+ value: true
+ }
+ ], stack);
+
+ assertSame(stack[0].holder[""], object);
+ assertSame(stack[0].value, object);
+ assertSame(stack[1].holder, replaced);
+ assertSame(stack[2].holder, replaced);
+})();
+
+(function testToJSON() {
+ var stack = [];
+ var object = {a: false, toJSON };
+ var nested = { toJSON: nestedToJSON };
+ var replaced = {a: false, replaced: true, nested };
+ var toJSONd = {a: false, toJSONd: true }
+ var nestedToJSONd = { nestedToJSONd: true };
+
+ function toJSON(key, value) {
+ return toJSONd;
+ }
+
+ function nestedToJSON(key, value) {
+ return nestedToJSONd;
+ }
+
+ function replacer(key, value) {
+ stack.push({ holder: this, key, value });
+ if (stack.length === 1) return replaced;
+ if (key === "a") return true;
+ return value;
+ }
+
+ assertEquals(`{"a":true,"replaced":true,"nested":{"nestedToJSONd":true}}`,
+ JSON.stringify(object, replacer));
+
+ assertEquals([
+ {
+ holder: { "": { a: false, toJSON: toJSON } },
+ key: "",
+ value: { a: false, toJSONd: true }
+ },
+ {
+ holder: { a: false, replaced: true, nested: { toJSON: nestedToJSON } },
+ key: "a",
+ value: false
+ },
+ {
+ holder: { a: false, replaced: true, nested: { toJSON: nestedToJSON } },
+ key: "replaced",
+ value: true
+ },
+ {
+ holder: { a: false, replaced: true, nested: { toJSON: nestedToJSON } },
+ key: "nested",
+ value: { nestedToJSONd: true }
+ },
+ {
+ holder: { nestedToJSONd: true },
+ key: "nestedToJSONd",
+ value: true
+ }
+ ], stack);
+
+ assertSame(stack[0].holder[""], object);
+ assertSame(stack[0].value, toJSONd);
+ assertSame(stack[1].holder, replaced);
+ assertSame(stack[2].holder, replaced);
+ assertSame(stack[3].holder, replaced);
+ assertSame(stack[3].value, nestedToJSONd);
+ assertSame(stack[4].holder, nestedToJSONd);
+})();
diff --git a/test/mjsunit/json.js b/test/mjsunit/json.js
index 84f2056..3652feb 100644
--- a/test/mjsunit/json.js
+++ b/test/mjsunit/json.js
@@ -234,7 +234,9 @@
function TestStringify(expected, input) {
assertEquals(expected, JSON.stringify(input));
- assertEquals(expected, JSON.stringify(input, null, 0));
+ assertEquals(expected, JSON.stringify(input, (key, value) => value));
+ assertEquals(JSON.stringify(input, null, "="),
+ JSON.stringify(input, (key, value) => value, "="));
}
TestStringify("true", true);
@@ -451,8 +453,8 @@
// RegExps are not callable, so they are stringified as objects.
TestStringify('{}', /regexp/);
TestStringify('42', counter);
-assertEquals(2, getCount);
-assertEquals(2, callCount);
+assertEquals(4, getCount);
+assertEquals(4, callCount);
var oddball2 = Object(42);
var oddball3 = Object("foo");
@@ -518,3 +520,6 @@
return p === "" ? v : 42;
}
assertEquals({a: 0, b: 1}, JSON.parse('{"a":0,"b":1}', reviver));
+
+reviver = (k, v) => (v === Infinity) ? "inf" : v;
+assertEquals('{"":"inf"}', JSON.stringify({"":Infinity}, reviver));
diff --git a/test/mjsunit/json2.js b/test/mjsunit/json2.js
index f68c76c..75e25f8 100644
--- a/test/mjsunit/json2.js
+++ b/test/mjsunit/json2.js
@@ -35,7 +35,9 @@
// Test JSON.stringify of array in dictionary mode.
function TestStringify(expected, input) {
assertEquals(expected, JSON.stringify(input));
- assertEquals(expected, JSON.stringify(input, null, 0));
+ assertEquals(expected, JSON.stringify(input, (key, value) => value));
+ assertEquals(JSON.stringify(input, null, "="),
+ JSON.stringify(input, (key, value) => value, "="));
}
var array_1 = [];
@@ -76,7 +78,7 @@
return 123;
} };
TestStringify('{"getter":123}', getter_obj);
-assertEquals(2, counter);
+assertEquals(4, counter);
// Test toJSON function.
var tojson_obj = { toJSON: function() {
@@ -85,7 +87,7 @@
},
a: 1};
TestStringify('[1,2]', tojson_obj);
-assertEquals(4, counter);
+assertEquals(8, counter);
// Test that we don't recursively look for the toJSON function.
var tojson_proto_obj = { a: 'fail' };
diff --git a/test/mjsunit/lithium/SeqStringSetChar.js b/test/mjsunit/lithium/SeqStringSetChar.js
deleted file mode 100644
index c5bd145..0000000
--- a/test/mjsunit/lithium/SeqStringSetChar.js
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2013 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.
-
-// Flags: --allow-natives-syntax
-
-function MyStringFromCharCode(code, i) {
- var one_byte = %NewString(3, true);
- %_OneByteSeqStringSetChar(0, code, one_byte);
- %_OneByteSeqStringSetChar(1, code, one_byte);
- %_OneByteSeqStringSetChar(i, code, one_byte);
- var two_byte = %NewString(3, false);
- %_TwoByteSeqStringSetChar(0, code, two_byte);
- %_TwoByteSeqStringSetChar(1, code, two_byte);
- %_TwoByteSeqStringSetChar(i, code, two_byte);
- return one_byte + two_byte;
-}
-
-MyStringFromCharCode(65, 2);
-var r1 = MyStringFromCharCode(65, 2);
-%OptimizeFunctionOnNextCall(MyStringFromCharCode);
-var r2 = MyStringFromCharCode(65, 2);
-assertEquals(r1, r2);
diff --git a/test/mjsunit/messages.js b/test/mjsunit/messages.js
index d40994d..30abc19 100644
--- a/test/mjsunit/messages.js
+++ b/test/mjsunit/messages.js
@@ -3,7 +3,7 @@
// found in the LICENSE file.
// Flags: --stack-size=100 --harmony
-// Flags: --harmony-simd --harmony-instanceof
+// Flags: --harmony-simd
function test(f, expected, type) {
try {
diff --git a/test/mjsunit/mirror-regexp.js b/test/mjsunit/mirror-regexp.js
index 7aae1c6..0711ff9 100644
--- a/test/mjsunit/mirror-regexp.js
+++ b/test/mjsunit/mirror-regexp.js
@@ -25,7 +25,7 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --expose-debug-as debug --harmony-unicode-regexps
+// Flags: --expose-debug-as debug
// Test the mirror object for regular expression values
var dont_enum = debug.PropertyAttribute.DontEnum;
diff --git a/test/mjsunit/mirror-script.js b/test/mjsunit/mirror-script.js
index ed0dd12..7e3891a 100644
--- a/test/mjsunit/mirror-script.js
+++ b/test/mjsunit/mirror-script.js
@@ -83,16 +83,7 @@
// Test the script mirror for different functions.
-testScriptMirror(function(){}, 'mirror-script.js', 99, 2, 0);
+testScriptMirror(function(){}, 'mirror-script.js', 90, 2, 0);
testScriptMirror(Math.abs, 'native math.js', -1, 0, 0);
testScriptMirror(eval('(function(){})'), null, 1, 2, 1, '(function(){})', 87);
testScriptMirror(eval('(function(){\n })'), null, 2, 2, 1, '(function(){\n })', 88);
-
-// Test taking slices of source.
-var mirror = debug.MakeMirror(eval('(function(){\n 1;\n})')).script();
-assertEquals('(function(){\n', mirror.sourceSlice(0, 1).sourceText());
-assertEquals(' 1;\n', mirror.sourceSlice(1, 2).sourceText());
-assertEquals('})', mirror.sourceSlice(2, 3).sourceText());
-assertEquals('(function(){\n 1;\n', mirror.sourceSlice(0, 2).sourceText());
-assertEquals(' 1;\n})', mirror.sourceSlice(1, 3).sourceText());
-assertEquals('(function(){\n 1;\n})', mirror.sourceSlice(0, 3).sourceText());
diff --git a/test/mjsunit/mjsunit.isolate b/test/mjsunit/mjsunit.isolate
index 18b73c2..6ebd801 100644
--- a/test/mjsunit/mjsunit.isolate
+++ b/test/mjsunit/mjsunit.isolate
@@ -13,7 +13,8 @@
'../../tools/profile_view.js',
'../../tools/profviz/composer.js',
'../../tools/splaytree.js',
- '../../tools/tickprocessor.js'
+ '../../tools/tickprocessor.js',
+ '../../tools/dumpcpp.js'
],
},
'includes': [
diff --git a/test/mjsunit/mjsunit.status b/test/mjsunit/mjsunit.status
index 228832b..017fa4d 100644
--- a/test/mjsunit/mjsunit.status
+++ b/test/mjsunit/mjsunit.status
@@ -94,14 +94,12 @@
'debug-evaluate-locals-optimized': [PASS, NO_VARIANTS],
'debug-evaluate-locals-optimized-double': [PASS, NO_VARIANTS],
'debug-evaluate-recursive': [PASS, NO_VARIANTS], # only in no-snap debug.
- 'debug-ignore-breakpoints': [PASS, NO_VARIANTS], # only in no-snap debug.
'debug-setbreakpoint': [PASS, NO_VARIANTS], # only in no-snap debug.
'debug-step': [PASS, NO_VARIANTS], # windows only.
'debug-step-2': [PASS, NO_VARIANTS], # flaky in no-snap mode.
'debug-step-3': [PASS, NO_VARIANTS], # flaky in no-snap mode.
'debug-stepframe-clearing': [PASS, NO_VARIANTS], # only in no-snap debug.
'debug-stepin-call-function-stub': [PASS, NO_VARIANTS], # only in no-snap debug.
- 'debug-stepin-positions': [PASS, NO_VARIANTS], # only due to inlining.
'regress/regress-3717': [PASS, NO_VARIANTS], # only in no-snap mode.
'regress/regress-2451': [PASS, NO_VARIANTS], # with custom snapshot and gc-stress.
'debug-multiple-breakpoints': [PASS, NO_VARIANTS], # with custom snapshot and gc-stress.
@@ -124,7 +122,6 @@
'mirror-script': [PASS, NO_VARIANTS], # on ARM64 only.
# TODO(jarin/mstarzinger): Investigate debugger issues with TurboFan.
- 'debug-evaluate-const': [PASS, NO_VARIANTS],
'debug-evaluate-locals': [PASS, NO_VARIANTS],
'debug-evaluate-locals-capturing': [PASS, NO_VARIANTS],
'debug-liveedit-check-stack': [PASS, NO_VARIANTS], # only in no-snap mode.
@@ -194,11 +191,6 @@
'regress/regress-crbug-482998': [PASS, NO_VARIANTS, ['arch == arm or arch == arm64 or arch == android_arm or arch == android_arm64 or arch == mipsel or arch == mips64el or arch == mips', SKIP]],
##############################################################################
- # This test expects to reach a certain recursion depth, which may not work
- # for debug mode.
- 'json-recursive': [PASS, ['mode == debug', PASS, FAIL]],
-
- ##############################################################################
# Skip long running tests that time out in debug mode.
'generated-transition-stub': [PASS, ['mode == debug', SKIP]],
'migrations': [SKIP],
@@ -214,6 +206,7 @@
# that, it doesn't make sense to run several variants of d8-os anyways.
'd8-os': [PASS, NO_VARIANTS, ['isolates or arch == android_arm or arch == android_arm64 or arch == android_ia32', SKIP]],
'tools/tickprocessor': [PASS, NO_VARIANTS, ['arch == android_arm or arch == android_arm64 or arch == android_ia32', SKIP]],
+ 'tools/dumpcpp': [PASS, NO_VARIANTS, ['arch == android_arm or arch == android_arm64 or arch == android_ia32', SKIP]],
##############################################################################
# Long running test that reproduces memory leak and should be run manually.
@@ -228,7 +221,6 @@
# Tests with different versions for release and debug.
'compiler/alloc-number': [PASS, ['mode == debug', SKIP]],
'compiler/alloc-number-debug': [PASS, ['mode == release', SKIP]],
- 'regress/regress-634': [PASS, ['mode == debug', SKIP]],
'regress/regress-634-debug': [PASS, ['mode == release', SKIP]],
# BUG(336820). TODO(bmeurer): Investigate.
@@ -261,7 +253,7 @@
'readonly': [PASS, SLOW],
'regress/regress-1200351': [PASS, ['mode == debug', SLOW]],
'regress/regress-crbug-474297': [PASS, ['mode == debug', SLOW]],
- 'es6/tail-call-megatest*': [PASS, FAST_VARIANTS],
+ 'es6/tail-call-megatest*': [PASS, SLOW, FAST_VARIANTS, ['tsan', SKIP]],
# TODO(titzer): ASM->WASM tests on these platforms
'wasm/asm-wasm': [PASS, ['arch in [arm, arm64, mips, mipsel, mips64, mips64el]', SKIP]],
@@ -276,12 +268,16 @@
'wasm/embenchen/*': [PASS, ['arch == arm64', SKIP], ['ignition == True', SKIP]],
# case-insensitive unicode regexp relies on case mapping provided by ICU.
- 'harmony/unicode-regexp-ignore-case': [PASS, ['no_i18n == True', FAIL]],
- 'harmony/unicode-regexp-ignore-case-noi18n': [FAIL, ['no_i18n == True', PASS]],
+ 'es6/unicode-regexp-ignore-case': [PASS, ['no_i18n == True', FAIL]],
+ 'es6/unicode-regexp-ignore-case-noi18n': [FAIL, ['no_i18n == True', PASS]],
'regress/regress-5036': [PASS, ['no_i18n == True', FAIL]],
# desugaring regexp property class relies on ICU.
'harmony/regexp-property-*': [PASS, ['no_i18n == True', FAIL]],
+ # TODO(bmeurer): Flaky timeouts (sometimes <1s, sometimes >3m).
+ 'unicodelctest': [PASS, NO_VARIANTS],
+ 'unicodelctest-no-optimization': [PASS, NO_VARIANTS],
+
############################################################################
# Ignition
@@ -296,12 +292,6 @@
# till it is optimized. So test timeouts.
'array-literal-transitions': [PASS, NO_IGNITION],
- # TODO(rmcilroy, 4680): Script throws RangeError as expected, but does so during
- # eager compile of the whole script instead of during lazy compile of the function
- # f(), so we can't catch the exception in the try/catch. Skip because on some
- # platforms the stack limit is different and the exception doesn't fire.
- 'regress/regress-crbug-589472': [PASS, NO_IGNITION],
-
# TODO(4680): Test doesn't know about three tier compiler pipeline.
'assert-opt-and-deopt': [PASS, NO_IGNITION],
@@ -336,6 +326,10 @@
'smi-mul-const': [PASS, NO_IGNITION],
'smi-mul': [PASS, NO_IGNITION],
'unary-minus-deopt': [PASS, NO_IGNITION],
+
+ # TODO(rmcilroy,5038): Crashes in Deoptimizer::PatchCodeForDeoptimization on
+ # nosnap builds when --stress-opt and --turbo-from-bytecode is enabled.
+ 'harmony/generators-turbo': [PASS, FAST_VARIANTS],
}], # ALWAYS
['novfp3 == True', {
@@ -382,7 +376,6 @@
# TODO(mstarzinger): Takes too long with TF.
'array-sort': [PASS, NO_VARIANTS],
'regress/regress-91008': [PASS, NO_VARIANTS],
- 'regress/regress-417709a': [PASS, ['arch == arm64', NO_VARIANTS]],
'regress/regress-transcendental': [PASS, ['arch == arm64', NO_VARIANTS]],
'compiler/osr-regress-max-locals': [PASS, NO_VARIANTS],
'math-floor-of-div': [PASS, NO_VARIANTS],
@@ -415,6 +408,9 @@
# BUG(v8:4779): Crashes flakily with stress mode on arm64.
'array-splice': [PASS, SLOW, ['arch == arm64', FAST_VARIANTS]],
+
+ # BUG(v8:5053).
+ 'wasm/embenchen/fasta': [PASS, FAST_VARIANTS],
}], # 'gc_stress == True'
##############################################################################
@@ -431,8 +427,6 @@
'asm/sqlite3/*': [SKIP],
# TODO(mips-team): Fix Wasm for big-endian.
'wasm/*': [SKIP],
- 'regress/regress-599717': [SKIP],
- 'regress/regress-599719': [SKIP],
}], # 'byteorder == big'
##############################################################################
@@ -454,15 +448,12 @@
'big-object-literal': [SKIP],
'compiler/regress-arguments': [SKIP],
'compiler/regress-gvn': [SKIP],
- 'compiler/regress-max-locals-for-osr': [SKIP],
'compiler/regress-4': [SKIP],
'compiler/regress-or': [SKIP],
'compiler/regress-rep-change': [SKIP],
'regress/regress-1117': [SKIP],
- 'regress/regress-1145': [SKIP],
'regress/regress-1849': [SKIP],
'regress/regress-3247124': [SKIP],
- 'regress/regress-634': [SKIP],
'regress/regress-91008': [SKIP],
'regress/regress-91010': [SKIP],
'regress/regress-91013': [SKIP],
@@ -518,11 +509,9 @@
['arch == arm64 and mode == debug and simulator_run == True', {
# Pass but take too long with the simulator in debug mode.
- 'array-iterate-backwards': [PASS, TIMEOUT],
'array-sort': [PASS, TIMEOUT],
'packed-elements': [SKIP],
'regexp-global': [SKIP],
- 'compiler/alloc-numbers': [SKIP],
'math-floor-of-div': [PASS, TIMEOUT],
'math-floor-of-div-nosudiv': [PASS, TIMEOUT],
'unicodelctest': [PASS, TIMEOUT],
@@ -532,7 +521,6 @@
# Ignition.
'es6/templates': [PASS, ['no_snap and mode == debug', NO_IGNITION]],
- 'harmony/generators': [PASS, ['no_snap and mode == debug', NO_IGNITION]],
'regress/regress-crbug-364374': [PASS, ['no_snap and mode == debug', NO_IGNITION]],
}], # 'arch == arm64 and mode == debug and simulator_run == True'
@@ -567,6 +555,9 @@
'try': [PASS, NO_IGNITION],
# Too slow for interpreter and msan.
'es6/tail-call-megatest*': [PASS, NO_IGNITION],
+
+ # Too slow.
+ 'harmony/regexp-property-lu-ui': [SKIP],
}], # 'msan == True'
##############################################################################
@@ -590,7 +581,6 @@
'big-object-literal': [SKIP],
'compiler/alloc-number': [SKIP],
'regress/regress-490': [SKIP],
- 'regress/regress-634': [SKIP],
'regress/regress-create-exception': [SKIP],
'regress/regress-3247124': [SKIP],
@@ -639,7 +629,6 @@
# the buildbot.
'compiler/alloc-number': [SKIP],
'regress/regress-490': [SKIP],
- 'regress/regress-634': [SKIP],
'regress/regress-create-exception': [SKIP],
'regress/regress-3247124': [SKIP],
@@ -702,7 +691,6 @@
'compiler/regress-3249650': [PASS, SLOW],
'compiler/simple-deopt': [PASS, SLOW],
'regress/regress-490': [PASS, SLOW],
- 'regress/regress-634': [PASS, SLOW],
'regress/regress-create-exception': [PASS, SLOW],
'regress/regress-3218915': [PASS, SLOW],
'regress/regress-3247124': [PASS, SLOW],
@@ -722,7 +710,6 @@
'big-object-literal': [PASS, ['mode == debug', SKIP]],
'math-floor-of-div': [PASS, ['mode == debug', SKIP]],
'math-floor-of-div-nosudiv': [PASS, ['mode == debug', SKIP]],
- 'osr-regress-max-locals': [PASS, ['mode == debug', SKIP]],
'unicodelctest': [PASS, ['mode == debug', SKIP]],
# BUG(v8:3435)
@@ -767,7 +754,6 @@
'regress/regress-1257': [PASS, NO_VARIANTS],
'regress/regress-2618': [PASS, NO_VARIANTS],
'regress/regress-298269': [PASS, NO_VARIANTS],
- 'regress/regress-634': [PASS, NO_VARIANTS],
'regress/regress-91008': [PASS, NO_VARIANTS],
'compiler/osr-alignment': [PASS, NO_VARIANTS],
'compiler/osr-one': [PASS, NO_VARIANTS],
@@ -852,18 +838,23 @@
# till it is optimized. So test timeouts.
'array-literal-transitions': [SKIP],
- # TODO(rmcilroy, 4680): Script throws RangeError as expected, but does so during
- # eager compile of the whole script instead of during lazy compile of the function
- # f(), so we can't catch the exception in the try/catch. Skip because on some
- # platforms the stack limit is different and the exception doesn't fire.
- 'regress/regress-crbug-589472': [SKIP],
-
'wasm/asm-wasm-f32': [PASS, ['arch in [arm64]', SKIP]],
'wasm/asm-wasm-f64': [PASS, ['arch in [arm64]', SKIP]],
# TODO(rmcilroy,titzer): Times out after
# https://codereview.chromium.org/1951013002 .
'regress/regress-599717': [PASS, ['tsan', SKIP]],
+
+ # TODO(rmcilroy,5038): Crashes in Deoptimizer::PatchCodeForDeoptimization on
+ # nosnap builds when --stress-opt and --turbo-from-bytecode is enabled.
+ 'harmony/generators-turbo': [PASS, FAST_VARIANTS],
+ 'regress/regress-crbug-352058': [SKIP],
+
+ # TODO(jarin): No truncations on CheckFloat64Hole.
+ 'getters-on-elements': [SKIP],
+
+ # TODO(rmcilroy): Flaky OOM.
+ 'unicodelctest-no-optimization': [SKIP],
}], # ignition or ignition_turbofan
['(ignition or ignition_turbofan) and arch == arm64', {
diff --git a/test/mjsunit/object-literal.js b/test/mjsunit/object-literal.js
index 19860ff..b861d44 100644
--- a/test/mjsunit/object-literal.js
+++ b/test/mjsunit/object-literal.js
@@ -24,8 +24,6 @@
// 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.
-//
-// Flags: --harmony-function-name
var obj = {
a: 7,
diff --git a/test/mjsunit/realm-property-access.js b/test/mjsunit/realm-property-access.js
new file mode 100644
index 0000000..679886d
--- /dev/null
+++ b/test/mjsunit/realm-property-access.js
@@ -0,0 +1,20 @@
+// 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.
+
+var r = Realm.create();
+var f = Realm.eval(r, "function f() { return this }; f()");
+assertEquals(f, Realm.global(r));
+
+// Cross-origin property access throws
+assertThrows(() => f.a, TypeError);
+assertThrows(() => { 'use strict'; f.a = 1 }, TypeError);
+
+var r2 = Realm.createAllowCrossRealmAccess();
+var f2 = Realm.eval(r2, "function f() { return this }; f()");
+assertEquals(f2, Realm.global(r2));
+
+// Same-origin property access doesn't throw
+assertEquals(undefined, f2.a);
+f2.a = 1;
+assertEquals(1, f2.a);
diff --git a/test/mjsunit/regexp-string-methods.js b/test/mjsunit/regexp-string-methods.js
index fa01a33..d5ad9c3 100644
--- a/test/mjsunit/regexp-string-methods.js
+++ b/test/mjsunit/regexp-string-methods.js
@@ -25,8 +25,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --no-harmony-regexp-exec
-
// Regexp shouldn't use String.prototype.slice()
var s = new String("foo");
assertEquals("f", s.slice(0,1));
@@ -43,11 +41,3 @@
var f2 = new RegExp("[g]", "i");
assertEquals(["G"], f2.exec("G"));
assertTrue(f2.ignoreCase);
-
-// On the other hand test is defined in a semi-coherent way as a call to exec.
-// 15.10.6.3
-// We match other browsers in using the original value of RegExp.prototype.exec.
-// I.e., RegExp.prototype.test shouldn't use the current value of
-// RegExp.prototype.exec.
-RegExp.prototype.exec = function(string) { return 'x'; };
-assertFalse(/f/.test('x'));
diff --git a/test/mjsunit/regress/regress-449070.js b/test/mjsunit/regress-crbug-619476.js
similarity index 61%
rename from test/mjsunit/regress/regress-449070.js
rename to test/mjsunit/regress-crbug-619476.js
index 7a0f0a8..33204ae 100644
--- a/test/mjsunit/regress/regress-449070.js
+++ b/test/mjsunit/regress-crbug-619476.js
@@ -1,10 +1,7 @@
// 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.
-//
-// Flags: --allow-natives-syntax
-try {
- %NormalizeElements(this);
-} catch(e) {
-}
+var x = {};
+// Crashes in debug mode if an erroneous DCHECK in dfb8d333 is not removed.
+eval, x[eval];
diff --git a/test/mjsunit/regress/redeclaration-error-types.js b/test/mjsunit/regress/redeclaration-error-types.js
new file mode 100644
index 0000000..72e097d
--- /dev/null
+++ b/test/mjsunit/regress/redeclaration-error-types.js
@@ -0,0 +1,145 @@
+// 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.
+
+
+function doTest(scripts, expectedError) {
+ var realm = Realm.create();
+
+ for (var i = 0; i < scripts.length - 1; i++) {
+ Realm.eval(realm, scripts[i]);
+ }
+ assertThrows(function() {
+ Realm.eval(realm, scripts[scripts.length - 1]);
+ }, Realm.eval(realm, expectedError));
+
+ Realm.dispose(realm);
+}
+
+var tests = [
+ {
+ // ES#sec-globaldeclarationinstantiation 5.a:
+ // If envRec.HasVarDeclaration(name) is true, throw a SyntaxError
+ // exception.
+ scripts: [
+ "var a;",
+ "let a;",
+ ],
+ expectedError: "SyntaxError",
+ },
+ {
+ // ES#sec-globaldeclarationinstantiation 6.a:
+ // If envRec.HasLexicalDeclaration(name) is true, throw a SyntaxError
+ // exception.
+ scripts: [
+ "let a;",
+ "var a;",
+ ],
+ expectedError: "SyntaxError",
+ },
+ {
+ // ES#sec-globaldeclarationinstantiation 5.b:
+ // If envRec.HasLexicalDeclaration(name) is true, throw a SyntaxError
+ // exception.
+ scripts: [
+ "let a;",
+ "let a;",
+ ],
+ expectedError: "SyntaxError",
+ },
+ {
+ // ES#sec-evaldeclarationinstantiation 5.a.i.1:
+ // If varEnvRec.HasLexicalDeclaration(name) is true, throw a SyntaxError
+ // exception.
+ scripts: [
+ 'let a; eval("var a;");',
+ ],
+ expectedError: "SyntaxError",
+ },
+ {
+ // ES#sec-evaldeclarationinstantiation 5.a.i.1:
+ // If varEnvRec.HasLexicalDeclaration(name) is true, throw a SyntaxError
+ // exception.
+ scripts: [
+ 'let a; eval("function a() {}");',
+ ],
+ expectedError: "SyntaxError",
+ },
+ {
+ // ES#sec-evaldeclarationinstantiation 5.d.ii.2.a.i:
+ // Throw a SyntaxError exception.
+ scripts: [
+ '(function() { let a; eval("var a;"); })();',
+ ],
+ expectedError: "SyntaxError",
+ },
+ {
+ // ES#sec-evaldeclarationinstantiation 5.d.ii.2.a.i:
+ // Throw a SyntaxError exception.
+ scripts: [
+ '(function() { let a; eval("function a() {}"); })();',
+ ],
+ expectedError: "SyntaxError",
+ },
+ {
+ // ES#sec-globaldeclarationinstantiation 5.d:
+ // If hasRestrictedGlobal is true, throw a SyntaxError exception.
+ scripts: [
+ 'let NaN;',
+ ],
+ expectedError: "SyntaxError",
+ },
+ {
+ // ES#sec-globaldeclarationinstantiation 5.d:
+ // If hasRestrictedGlobal is true, throw a SyntaxError exception.
+ scripts: [
+ 'function NaN() {}',
+ ],
+ expectedError: "SyntaxError",
+ },
+
+ {
+ // ES#sec-evaldeclarationinstantiation 8.a.iv.1.b:
+ // If fnDefinable is false, throw a TypeError exception.
+ scripts: [
+ 'eval("function NaN() {}");',
+ ],
+ expectedError: "TypeError",
+ },
+ {
+ // ES#sec-evaldeclarationinstantiation 8.a.iv.1.b:
+ // If fnDefinable is false, throw a TypeError exception.
+ scripts: [
+ `
+ let a;
+ try {
+ eval("function a() {}");
+ } catch (e) {}
+ eval("function NaN() {}");
+ `,
+ ],
+ expectedError: "TypeError",
+ },
+ {
+ // ES#sec-evaldeclarationinstantiation 8.a.iv.1.b:
+ // If fnDefinable is false, throw a TypeError exception.
+ scripts: [
+ `
+ eval("
+ function f() {
+ function b() {
+ (0, eval)('function NaN() {}');
+ }
+ b();
+ }
+ f();
+ ");
+ `.replace(/"/g, '`'),
+ ],
+ expectedError: "TypeError",
+ },
+];
+
+tests.forEach(function(test) {
+ doTest(test.scripts, test.expectedError);
+});
diff --git a/test/mjsunit/regress/regress-1132.js b/test/mjsunit/regress/regress-1132.js
index a5cb0a1..adb56b0 100644
--- a/test/mjsunit/regress/regress-1132.js
+++ b/test/mjsunit/regress/regress-1132.js
@@ -28,7 +28,7 @@
// Test the case when exception is thrown from the parser when lazy
// compiling a function.
-// Flags: --stack-size=46
+// Flags: --stack-size=100
// NOTE: stack size constant above has been empirically chosen.
// If the test starts to fail in Genesis, consider increasing this constant.
diff --git a/test/mjsunit/regress/regress-1246.js b/test/mjsunit/regress/regress-1246.js
deleted file mode 100644
index ca425ec..0000000
--- a/test/mjsunit/regress/regress-1246.js
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2011 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.
-
-// This regression tests the behaviour of the parseInt function when
-// the given radix is not a SMI.
-
-// Flags: --allow-natives-syntax
-
-var nonSmi10 = Math.log(Math.exp(10));
-var nonSmi16 = Math.log(Math.exp(16));
-
-assertTrue(!%_IsSmi(nonSmi10) && nonSmi10 == 10);
-assertTrue(!%_IsSmi(nonSmi16) && nonSmi16 == 16);
-
-// Giving these values as the radix argument triggers radix detection.
-var radix_detect = [0, -0, NaN, Infinity, -Infinity, undefined, null,
- "0", "-0", "a"];
-
-// These values will result in an integer radix outside of the valid range.
-var radix_invalid = [1, 37, -2, "-2", "37"];
-
-// These values will trigger decimal parsing.
-var radix10 = [10, 10.1, "10", "10.1", nonSmi10];
-
-// These values will trigger hexadecimal parsing.
-var radix16 = [16, 16.1, 0x10, "0X10", nonSmi16];
-
-for (var i = 0; i < radix_detect.length; i++) {
- var radix = radix_detect[i];
- assertEquals(NaN, parseInt("", radix));
- assertEquals(23, parseInt("23", radix));
- assertEquals(0xaf, parseInt("0xaf", radix));
- assertEquals(NaN, parseInt("af", radix));
-}
-
-for (var i = 0; i < radix_invalid.length; i++) {
- var radix = radix_invalid[i];
- assertEquals(NaN, parseInt("", radix));
- assertEquals(NaN, parseInt("23", radix));
- assertEquals(NaN, parseInt("0xaf", radix));
- assertEquals(NaN, parseInt("af", radix));
-}
-
-for (var i = 0; i < radix10.length; i++) {
- var radix = radix10[i];
- assertEquals(NaN, parseInt("", radix));
- assertEquals(23, parseInt("23", radix));
- assertEquals(0, parseInt("0xaf", radix));
- assertEquals(NaN, parseInt("af", radix));
-}
-
-for (var i = 0; i < radix16.length; i++) {
- var radix = radix16[i];
- assertEquals(NaN, parseInt("", radix));
- assertEquals(0x23, parseInt("23", radix));
- assertEquals(0xaf, parseInt("0xaf", radix));
- assertEquals(0xaf, parseInt("af", radix));
-}
diff --git a/test/mjsunit/regress/regress-403292.js b/test/mjsunit/regress/regress-403292.js
deleted file mode 100644
index 2e24d48..0000000
--- a/test/mjsunit/regress/regress-403292.js
+++ /dev/null
@@ -1,55 +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.
-
-// Flags: --allow-natives-syntax --expose-natives-as=builtins --expose-gc
-
-var SetIterator = builtins.ImportNow("SetIterator");
-var MapIterator = builtins.ImportNow("MapIterator");
-var __v_7 = [];
-var __v_8 = {};
-var __v_10 = {};
-var __v_11 = this;
-var __v_12 = {};
-var __v_13 = {};
-var __v_14 = "";
-var __v_15 = {};
-try {
-__v_1 = {x:0};
-%OptimizeFunctionOnNextCall(__f_1);
-assertEquals("good", __f_1());
-delete __v_1.x;
-assertEquals("good", __f_1());
-} catch(e) { print("Caught: " + e); }
-try {
-__v_3 = new Set();
-__v_5 = new SetIterator(__v_3, -12);
-__v_4 = new Map();
-__v_6 = new MapIterator(__v_4, 2);
-__f_3(Array);
-} catch(e) { print("Caught: " + e); }
-function __f_4(__v_8, filter) {
- function __f_6(v) {
- for (var __v_4 in v) {
- for (var __v_4 in v) {}
- }
- %OptimizeFunctionOnNextCall(filter);
- return filter(v);
- }
- var __v_7 = eval(__v_8);
- gc();
- return __f_6(__v_7);
-}
-function __f_5(__v_6) {
- var __v_5 = new Array(__v_6);
- for (var __v_4 = 0; __v_4 < __v_6; __v_4++) __v_5.push('{}');
- return __v_5;
-}
-try {
-try {
- __v_8.test("\x80");
- assertUnreachable();
-} catch (e) {
-}
-gc();
-} catch(e) { print("Caught: " + e); }
diff --git a/test/mjsunit/regress/regress-4659.js b/test/mjsunit/regress/regress-4659.js
index ff436be..8992bb8 100644
--- a/test/mjsunit/regress/regress-4659.js
+++ b/test/mjsunit/regress/regress-4659.js
@@ -1,8 +1,6 @@
// 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.
-//
-// Flags: --harmony-function-name
var obj = {
get longerName(){
diff --git a/test/mjsunit/regress/regress-4665-2.js b/test/mjsunit/regress/regress-4665-2.js
deleted file mode 100644
index b94301e..0000000
--- a/test/mjsunit/regress/regress-4665-2.js
+++ /dev/null
@@ -1,33 +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.
-
-// Flags: --harmony-species
-
-// First test case
-
-function FirstBuffer () {}
-FirstBuffer.prototype.__proto__ = Uint8Array.prototype
-FirstBuffer.__proto__ = Uint8Array
-
-var buf = new Uint8Array(10)
-buf.__proto__ = FirstBuffer.prototype
-
-var buf2 = buf.subarray(2)
-assertEquals(8, buf2.length);
-
-// Second test case
-
-function SecondBuffer (arg) {
- var arr = new Uint8Array(arg)
- arr.__proto__ = SecondBuffer.prototype
- return arr
-}
-SecondBuffer.prototype.__proto__ = Uint8Array.prototype
-SecondBuffer.__proto__ = Uint8Array
-
-var buf3 = new SecondBuffer(10)
-
-var buf4 = buf3.subarray(2)
-
-assertEquals(8, buf4.length);
diff --git a/test/mjsunit/regress/regress-4665.js b/test/mjsunit/regress/regress-4665.js
index 9d7307a..a75d68f 100644
--- a/test/mjsunit/regress/regress-4665.js
+++ b/test/mjsunit/regress/regress-4665.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --noharmony-species
-
// First test case
function FirstBuffer () {}
diff --git a/test/mjsunit/regress/regress-4703.js b/test/mjsunit/regress/regress-4703.js
new file mode 100644
index 0000000..dad8a97
--- /dev/null
+++ b/test/mjsunit/regress/regress-4703.js
@@ -0,0 +1,30 @@
+// 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.
+
+// Flags: --expose-debug-as debug
+
+function listener(event, exec_state, event_data, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var all_scopes = exec_state.frame().allScopes();
+ assertEquals([ debug.ScopeType.Block,
+ debug.ScopeType.Local,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global ],
+ all_scopes.map(scope => scope.scopeType()));
+ } catch (e) {
+ exception = e;
+ }
+}
+
+debug.Debug.setListener(listener);
+
+(function(arg, ...rest) {
+ var one = 1;
+ function inner() {
+ one;
+ arg;
+ }
+ debugger;
+})();
diff --git a/test/mjsunit/regress/regress-4815.js b/test/mjsunit/regress/regress-4815.js
new file mode 100644
index 0000000..00e61cb
--- /dev/null
+++ b/test/mjsunit/regress/regress-4815.js
@@ -0,0 +1,38 @@
+// 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.
+
+var thrower = { [Symbol.toPrimitive]: () => FAIL };
+
+// Tests that a native conversion function is included in the
+// stack trace.
+function testTraceNativeConversion(nativeFunc) {
+ var nativeFuncName = nativeFunc.name;
+ try {
+ nativeFunc(thrower);
+ assertUnreachable(nativeFuncName);
+ } catch (e) {
+ assertTrue(e.stack.indexOf(nativeFuncName) >= 0, nativeFuncName);
+ }
+}
+
+testTraceNativeConversion(Math.max);
+testTraceNativeConversion(Math.min);
+
+function testBuiltinInStackTrace(script, nativeFuncName) {
+ try {
+ eval(script);
+ assertUnreachable(nativeFuncName);
+ } catch (e) {
+ assertTrue(e.stack.indexOf(nativeFuncName) >= 0, nativeFuncName);
+ }
+}
+
+// Use the full name ('String.getDate') in order to avoid false pass
+// results when the method name is mentioned in the error message itself.
+// This occurs, e.g., for Date.prototype.getYear, which uses a different code
+// path and never hits the Generate_DatePrototype_GetField builtin.
+testBuiltinInStackTrace("Date.prototype.getDate.call('')", "String.getDate");
+testBuiltinInStackTrace("Date.prototype.getUTCDate.call('')",
+ "String.getUTCDate");
+testBuiltinInStackTrace("Date.prototype.getTime.call('')", "String.getTime");
diff --git a/test/mjsunit/regress/regress-5004.js b/test/mjsunit/regress/regress-5004.js
new file mode 100644
index 0000000..234f5d4
--- /dev/null
+++ b/test/mjsunit/regress/regress-5004.js
@@ -0,0 +1,27 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+function assertAsync(b, s) {
+ if (!b) {
+ %AbortJS(" FAILED!")
+ }
+}
+
+class P extends Promise {
+ constructor() {
+ super(...arguments)
+ return new Proxy(this, {
+ get: (_, key) => {
+ return key == 'then' ?
+ this.then.bind(this) :
+ this.constructor.resolve(20)
+ }
+ })
+ }
+}
+
+let p = P.resolve(10)
+p.key.then(v => assertAsync(v === 20));
diff --git a/test/mjsunit/regress/regress-5018.js b/test/mjsunit/regress/regress-5018.js
new file mode 100644
index 0000000..22025dc
--- /dev/null
+++ b/test/mjsunit/regress/regress-5018.js
@@ -0,0 +1,29 @@
+// 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.
+
+var dv = new DataView(new ArrayBuffer(4), 2);
+
+function getByteLength(a) {
+ return a.byteLength;
+}
+
+assertEquals(2, getByteLength(dv));
+assertEquals(2, getByteLength(dv));
+
+Object.defineProperty(dv.__proto__, 'byteLength', {value: 42});
+
+assertEquals(42, dv.byteLength);
+assertEquals(42, getByteLength(dv));
+
+function getByteOffset(a) {
+ return a.byteOffset;
+}
+
+assertEquals(2, getByteOffset(dv));
+assertEquals(2, getByteOffset(dv));
+
+Object.defineProperty(dv.__proto__, 'byteOffset', {value: 42});
+
+assertEquals(42, dv.byteOffset);
+assertEquals(42, getByteOffset(dv));
diff --git a/test/mjsunit/regress/regress-5036.js b/test/mjsunit/regress/regress-5036.js
index 036edd9..77bd242 100644
--- a/test/mjsunit/regress/regress-5036.js
+++ b/test/mjsunit/regress/regress-5036.js
@@ -2,6 +2,4 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps
-
assertEquals(["1\u212a"], /\d\w/ui.exec("1\u212a"));
diff --git a/test/mjsunit/regress/regress-5071.js b/test/mjsunit/regress/regress-5071.js
new file mode 100644
index 0000000..41c1250
--- /dev/null
+++ b/test/mjsunit/regress/regress-5071.js
@@ -0,0 +1,26 @@
+// 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.
+
+// Flags: --expose-debug-as debug
+
+var Debug = debug.Debug;
+
+function listener(event, exec_state, event_data, data) {
+ assertEquals(2, exec_state.frameCount());
+ assertEquals("a", exec_state.frame(0).localName(0));
+ assertEquals("1", exec_state.frame(0).localValue(0).value());
+ assertEquals(1, exec_state.frame(0).localCount());
+}
+
+Debug.setListener(listener);
+
+function f() {
+ var a = 1;
+ {
+ let b = 2;
+ debugger;
+ }
+}
+
+f();
diff --git a/test/mjsunit/regress/regress-5085.js b/test/mjsunit/regress/regress-5085.js
new file mode 100644
index 0000000..0ed034d
--- /dev/null
+++ b/test/mjsunit/regress/regress-5085.js
@@ -0,0 +1,14 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+function foo(x) {
+ return x instanceof Proxy;
+}
+
+assertFalse(foo({}));
+assertFalse(foo({}));
+%OptimizeFunctionOnNextCall(foo);
+assertFalse(foo({}));
diff --git a/test/mjsunit/regress/regress-5106.js b/test/mjsunit/regress/regress-5106.js
new file mode 100644
index 0000000..52d550a
--- /dev/null
+++ b/test/mjsunit/regress/regress-5106.js
@@ -0,0 +1,29 @@
+// 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.
+
+function* g1() {
+ try {
+ throw {};
+ } catch ({a = class extends (yield) {}}) {
+ }
+}
+g1().next(); // crashes without fix
+
+function* g2() {
+ let x = function(){};
+ try {
+ throw {};
+ } catch ({b = class extends x {}}) {
+ }
+}
+g2().next(); // crashes without fix
+
+function* g3() {
+ let x = 42;
+ try {
+ throw {};
+ } catch ({c = (function() { return x })()}) {
+ }
+}
+g3().next(); // throws a ReferenceError without fix
diff --git a/test/mjsunit/regress/regress-5174.js b/test/mjsunit/regress/regress-5174.js
new file mode 100644
index 0000000..390d24e
--- /dev/null
+++ b/test/mjsunit/regress/regress-5174.js
@@ -0,0 +1,6 @@
+// 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.
+
+assertEquals([], Object.keys(new Proxy([], {})));
+assertEquals([], Object.keys(new Proxy(/regex/, {})));
diff --git a/test/mjsunit/regress/regress-544991.js b/test/mjsunit/regress/regress-544991.js
index 911d8ac..a9fd809 100644
--- a/test/mjsunit/regress/regress-544991.js
+++ b/test/mjsunit/regress/regress-544991.js
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-species
-
'use strict';
var typedArray = new Int8Array(1);
diff --git a/test/mjsunit/regress/regress-612146.js b/test/mjsunit/regress/regress-612146.js
new file mode 100644
index 0000000..1bd3f0b
--- /dev/null
+++ b/test/mjsunit/regress/regress-612146.js
@@ -0,0 +1,33 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+function f() {
+ var arguments_ = arguments;
+ if (undefined) {
+ while (true) {
+ arguments_[0];
+ }
+ } else {
+ %DeoptimizeNow();
+ return arguments_[0];
+ }
+};
+
+f(0);
+f(0);
+%OptimizeFunctionOnNextCall(f);
+assertEquals(1, f(1));
+
+function g() {
+ var a = arguments;
+ %DeoptimizeNow();
+ return a.length;
+}
+
+g(1);
+g(1);
+%OptimizeFunctionOnNextCall(g);
+assertEquals(1, g(1));
diff --git a/test/mjsunit/regress/regress-612412.js b/test/mjsunit/regress/regress-612412.js
new file mode 100644
index 0000000..3debe66
--- /dev/null
+++ b/test/mjsunit/regress/regress-612412.js
@@ -0,0 +1,20 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+function counter() { return {x: 0} || this }
+
+var f = (function() {
+ "use asm";
+ return function g(c1, c2) {
+ for (var x = 0 ; x < 10; ++x) {
+ if (x == 5) %OptimizeOsr();
+ c1();
+ }
+ }
+})();
+
+g = (function() { f((Array), counter()); });
+g();
diff --git a/test/mjsunit/regress/regress-615776.js b/test/mjsunit/regress/regress-615776.js
new file mode 100644
index 0000000..7e89b56
--- /dev/null
+++ b/test/mjsunit/regress/regress-615776.js
@@ -0,0 +1,14 @@
+// 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.
+
+Object.defineProperty(Int32Array.prototype.__proto__, 'length', {
+ get: function() { throw new Error('Custom length property'); }
+});
+
+var a = Math.random();
+
+// This tests MathRandomRaw.
+var v0 = new Set();
+var v1 = new Object();
+v0.add(v1);
diff --git a/test/mjsunit/regress/regress-617525.js b/test/mjsunit/regress/regress-617525.js
new file mode 100644
index 0000000..bb77e06
--- /dev/null
+++ b/test/mjsunit/regress/regress-617525.js
@@ -0,0 +1,11 @@
+// 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.
+
+function __f_14() {
+ "use asm";
+ function __f_15() { return 0; }
+ function __f_15() { return 137; } // redeclared function
+ return {};
+}
+assertThrows(function() { Wasm.instantiateModuleFromAsm(__f_14.toString()) });
diff --git a/test/mjsunit/regress/regress-617529.js b/test/mjsunit/regress/regress-617529.js
new file mode 100644
index 0000000..415e6c7
--- /dev/null
+++ b/test/mjsunit/regress/regress-617529.js
@@ -0,0 +1,14 @@
+// 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.
+
+function __f_71(stdlib, buffer) {
+ "use asm";
+ var __v_22 = new stdlib.Float64Array(buffer);
+ function __f_26() {
+ __v_22 = __v_22;
+ }
+ return {__f_26: __f_26};
+}
+
+assertThrows(function() { Wasm.instantiateModuleFromAsm( __f_71.toString()); });
diff --git a/test/mjsunit/regress/regress-618657.js b/test/mjsunit/regress/regress-618657.js
new file mode 100644
index 0000000..2882cff
--- /dev/null
+++ b/test/mjsunit/regress/regress-618657.js
@@ -0,0 +1,14 @@
+// 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.
+
+// Flags: --ignition --ignition-generators --ignition-filter=-foo
+
+function* foo() { yield 42 }
+function* goo() { yield 42 }
+var f = foo();
+var g = goo();
+assertEquals(42, f.next().value);
+assertEquals(42, g.next().value);
+assertEquals(true, f.next().done);
+assertEquals(true, g.next().done);
diff --git a/test/mjsunit/regress/regress-620750.js b/test/mjsunit/regress/regress-620750.js
new file mode 100644
index 0000000..ab8fbd9
--- /dev/null
+++ b/test/mjsunit/regress/regress-620750.js
@@ -0,0 +1,14 @@
+// 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.
+
+// Flags: --es-staging
+
+function push_a_lot(arr) {
+ for (var i = 0; i < 2e4; i++) {
+ arr.push(i);
+ }
+ return arr;
+}
+
+__v_13 = push_a_lot([]);
diff --git a/test/mjsunit/regress/regress-622663.js b/test/mjsunit/regress/regress-622663.js
new file mode 100644
index 0000000..9606bd8
--- /dev/null
+++ b/test/mjsunit/regress/regress-622663.js
@@ -0,0 +1,14 @@
++// 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.
++
++// Flags: --no-lazy
+
+(function() {
+ try { (y = [...[]]) => {} } catch(_) {} // will core dump, if not fixed
+})();
+
+(function() {
+ try { ((y = [...[]]) => {})(); } catch(_) {} // will core dump, if not fixed,
+ // even without --no-lazy
+})();
diff --git a/test/mjsunit/regress/regress-crbug-320922.js b/test/mjsunit/regress/regress-crbug-320922.js
deleted file mode 100644
index f199628..0000000
--- a/test/mjsunit/regress/regress-crbug-320922.js
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2013 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.
-
-// Flags: --allow-natives-syntax
-
-var string = "internalized dummy";
-var expected = "internalized dummy";
-string = "hello world";
-expected = "Hello " + "world";
-function Capitalize() {
- %_OneByteSeqStringSetChar(0, 0x48, string);
-}
-Capitalize();
-assertEquals(expected, string);
-Capitalize();
-assertEquals(expected, string);
-
-var twobyte = "\u20ACello world";
-
-function TwoByteCapitalize() {
- %_TwoByteSeqStringSetChar(0, 0x48, twobyte);
-}
-TwoByteCapitalize();
-assertEquals(expected, twobyte);
-TwoByteCapitalize();
-assertEquals(expected, twobyte);
diff --git a/test/mjsunit/regress/regress-crbug-495493.js b/test/mjsunit/regress/regress-crbug-495493.js
new file mode 100644
index 0000000..3dba236
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-495493.js
@@ -0,0 +1,12 @@
+// 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.
+
+// Flags: --nofold-constants --enable-slow-asserts --debug-code
+
+function foo(p) {
+ for (var i = 0; i < 100000; ++i) {
+ p = Math.min(-1, 0);
+ }
+}
+foo(0);
diff --git a/test/mjsunit/regress/regress-crbug-498142.js b/test/mjsunit/regress/regress-crbug-498142.js
deleted file mode 100644
index fcec5d1..0000000
--- a/test/mjsunit/regress/regress-crbug-498142.js
+++ /dev/null
@@ -1,8 +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.
-
-// Flags: --allow-natives-syntax --harmony-sharedarraybuffer
-
-var sab = new SharedArrayBuffer(16);
-assertThrows(function() { %ArrayBufferNeuter(sab); });
diff --git a/test/mjsunit/regress/regress-crbug-600995.js b/test/mjsunit/regress/regress-crbug-600995.js
deleted file mode 100644
index c532608..0000000
--- a/test/mjsunit/regress/regress-crbug-600995.js
+++ /dev/null
@@ -1,10 +0,0 @@
-// 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.
-
-// Flags: --noharmony-iterator-close
-
-// The {Set} function will produce a different type feedback vector layout
-// depending on whether Harmony iterator finalization is enabled or not.
-
-new Set();
diff --git a/test/mjsunit/regress/regress-crbug-605862.js b/test/mjsunit/regress/regress-crbug-605862.js
index 3124c06..82a5d45 100644
--- a/test/mjsunit/regress/regress-crbug-605862.js
+++ b/test/mjsunit/regress/regress-crbug-605862.js
@@ -2,7 +2,5 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-unicode-regexps
-
/[]*1/u.exec("\u1234");
/[^\u0000-\u{10ffff}]*1/u.exec("\u1234");
diff --git a/test/mjsunit/regress/regress-crbug-612109.js b/test/mjsunit/regress/regress-crbug-612109.js
new file mode 100644
index 0000000..202bd96
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-612109.js
@@ -0,0 +1,8 @@
+// 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.
+
+
+s = "string for triggering osr in __f_0";
+for (var i = 0; i < 16; i++) s = s + s;
+decodeURI(encodeURI(s));
diff --git a/test/mjsunit/regress/regress-crbug-613494.js b/test/mjsunit/regress/regress-crbug-613494.js
new file mode 100644
index 0000000..6fcc1e9
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-613494.js
@@ -0,0 +1,14 @@
+// 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.
+
+// Flags: --allow-natives-syntax --turbo-escape --noanalyze-environment-liveness
+
+function f() {
+ var bound = 0;
+ function g() { return bound }
+}
+f();
+f();
+%OptimizeFunctionOnNextCall(f);
+f();
diff --git a/test/mjsunit/regress/regress-crbug-613570.js b/test/mjsunit/regress/regress-crbug-613570.js
new file mode 100644
index 0000000..3cd9857
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-613570.js
@@ -0,0 +1,6 @@
+// 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.
+
+assertEquals("[\n\u26031,\n\u26032\n]",
+ JSON.stringify([1, 2], null, "\u2603"));
diff --git a/test/mjsunit/regress/regress-crbug-613905.js b/test/mjsunit/regress/regress-crbug-613905.js
new file mode 100644
index 0000000..8bb38c9
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-613905.js
@@ -0,0 +1,11 @@
+// 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.
+
+Error.prepareStackTrace = (e,s) => s;
+var CallSiteConstructor = Error().stack[0].constructor;
+
+try {
+ (new CallSiteConstructor(3, 6)).toString();
+} catch (e) {
+}
diff --git a/test/mjsunit/regress/regress-crbug-613919.js b/test/mjsunit/regress/regress-crbug-613919.js
new file mode 100644
index 0000000..cbd3e43
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-613919.js
@@ -0,0 +1,18 @@
+// 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.
+
+// Flags: --allow-natives-syntax --turbo-escape
+
+function g(a) {
+ if (a) return arguments;
+ %DeoptimizeNow();
+ return 23;
+}
+function f() {
+ return g(false);
+}
+assertEquals(23, f());
+assertEquals(23, f());
+%OptimizeFunctionOnNextCall(f);
+assertEquals(23, f());
diff --git a/test/mjsunit/regress/regress-crbug-614292.js b/test/mjsunit/regress/regress-crbug-614292.js
new file mode 100644
index 0000000..3a67c17
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-614292.js
@@ -0,0 +1,14 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+function foo() {
+ return [] | 0 && values[0] || false;
+}
+
+%OptimizeFunctionOnNextCall(foo);
+try {
+ foo();
+} catch (e) {}
diff --git a/test/mjsunit/regress/regress-crbug-614727.js b/test/mjsunit/regress/regress-crbug-614727.js
new file mode 100644
index 0000000..0845afc
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-614727.js
@@ -0,0 +1,23 @@
+// 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.
+
+"use strict";
+
+function f(a, b, c) { return arguments }
+function g(...args) { return args }
+
+// On 64-bit machine this produces a 768K array which is sufficiently small to
+// not cause a stack overflow, but big enough to move the allocated arguments
+// object into large object space (kMaxRegularHeapObjectSize == 600K).
+var length = Math.pow(2, 15) * 3;
+var args = new Array(length);
+assertEquals(length, f.apply(null, args).length);
+assertEquals(length, g.apply(null, args).length);
+
+// On 32-bit machines this produces an equally sized array, however it might in
+// turn trigger a stack overflow on 64-bit machines, which we need to catch.
+var length = Math.pow(2, 16) * 3;
+var args = new Array(length);
+try { f.apply(null, args) } catch(e) {}
+try { g.apply(null, args) } catch(e) {}
diff --git a/test/mjsunit/regress/regress-crbug-615774.js b/test/mjsunit/regress/regress-crbug-615774.js
new file mode 100644
index 0000000..ea5e675
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-615774.js
@@ -0,0 +1,11 @@
+// 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.
+
+Error.prepareStackTrace = (e,s) => s;
+var CallSiteConstructor = Error().stack[0].constructor;
+
+try {
+ (new CallSiteConstructor(CallSiteConstructor, 6)).toString();
+} catch (e) {
+}
diff --git a/test/mjsunit/regress/regress-crbug-617527.js b/test/mjsunit/regress/regress-crbug-617527.js
new file mode 100644
index 0000000..cf46628
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-617527.js
@@ -0,0 +1,8 @@
+// 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.
+
+// Flags: --enable-slow-asserts
+
+Object.defineProperty(Array.prototype, "1", { get: toLocaleString });
+assertThrows(_ => new RegExp(0, 0));
diff --git a/test/mjsunit/regress/regress-crbug-617567.js b/test/mjsunit/regress/regress-crbug-617567.js
new file mode 100644
index 0000000..f0c696e
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-617567.js
@@ -0,0 +1,24 @@
+// 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.
+
+// Flags: --turbo-filter=* --allow-natives-syntax
+
+var v1 = {};
+function g() {
+ v1 = [];
+ for (var i = 0; i < 1; i++) {
+ v1[i]();
+ }
+}
+
+var v2 = {};
+var v3 = {};
+function f() {
+ v3 = v2;
+ g();
+}
+
+assertThrows(g);
+%OptimizeFunctionOnNextCall(f);
+assertThrows(f);
diff --git a/test/mjsunit/regress/regress-crbug-618788.js b/test/mjsunit/regress/regress-crbug-618788.js
new file mode 100644
index 0000000..a104d8d
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-618788.js
@@ -0,0 +1,21 @@
+// 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.
+
+// Slice and splice both try to set the length property of their return
+// value. Add a bogus setter to allow that.
+Object.defineProperty(Int32Array.prototype, 'length', { set(v) { } });
+
+(function testSlice() {
+ var a = new Array();
+ a.constructor = Int32Array;
+ a.length = 1000; // Make the length >= 1000 so UseSparseVariant returns true.
+ assertTrue(a.slice() instanceof Int32Array);
+})();
+
+(function testSplice() {
+ var a = new Array();
+ a.constructor = Int32Array;
+ a.length = 1000; // Make the length >= 1000 so UseSparseVariant returns true.
+ assertTrue(a.splice(1) instanceof Int32Array);
+})();
diff --git a/test/mjsunit/regress/regress-crbug-618845.js b/test/mjsunit/regress/regress-crbug-618845.js
new file mode 100644
index 0000000..ea3baba
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-618845.js
@@ -0,0 +1,16 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+function Foo() {}
+Object.defineProperty(Foo.prototype, "name",
+ {get: function() { return "FooName"; }});
+
+function ic(f) {
+ return f.prototype.name;
+}
+
+assertEquals("FooName", ic(Foo));
+assertEquals("FooName", ic(Foo)); // Don't crash, don't time out.
diff --git a/test/mjsunit/regress/regress-crbug-620253.js b/test/mjsunit/regress/regress-crbug-620253.js
new file mode 100644
index 0000000..811a4e7
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-620253.js
@@ -0,0 +1,7 @@
+// 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.
+
+// Flags: --throws
+
+load("test/mjsunit/regress/regress-crbug-620253.js");
diff --git a/test/mjsunit/regress/regress-crbug-620650.js b/test/mjsunit/regress/regress-crbug-620650.js
new file mode 100644
index 0000000..25a92ca
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-620650.js
@@ -0,0 +1,16 @@
+// 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.
+
+(function() {
+ function f(src, dst, i) {
+ dst[i] = src[i];
+ }
+ var buf = new ArrayBuffer(16);
+ var view_int32 = new Int32Array(buf);
+ view_int32[1] = 0xFFF7FFFF;
+ var view_f64 = new Float64Array(buf);
+ var arr = [,0.1];
+ f(view_f64, arr, -1);
+ f(view_f64, arr, 0);
+})();
diff --git a/test/mjsunit/regress/regress-crbug-621361.js b/test/mjsunit/regress/regress-crbug-621361.js
new file mode 100644
index 0000000..f9496ae
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-621361.js
@@ -0,0 +1,40 @@
+// 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.
+
+// Flags: --expose-debug-as debug
+
+var Debug = debug.Debug;
+var steps = 0;
+var exception = null;
+
+function listener(event, execState, eventData, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ assertEquals([ debug.ScopeType.Local,
+ debug.ScopeType.Script,
+ debug.ScopeType.Global],
+ execState.frame().allScopes().map(s => s.scopeType()));
+ var x_value = execState.frame().evaluate("x").value();
+ if (steps < 2) {
+ assertEquals(undefined, x_value);
+ execState.prepareStep(Debug.StepAction.StepIn);
+ } else {
+ assertEquals("l => l", x_value.toString());
+ }
+ steps++;
+ } catch (e) {
+ exception = e;
+ }
+}
+
+Debug.setListener(listener);
+
+(function() {
+ debugger;
+ var x = l => l;
+})();
+
+Debug.setListener(null);
+assertNull(exception);
+assertEquals(3, steps);
diff --git a/test/mjsunit/regress/regress-crbug-621611.js b/test/mjsunit/regress/regress-crbug-621611.js
new file mode 100644
index 0000000..bf9a460
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-621611.js
@@ -0,0 +1,11 @@
+// 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.
+
+assertEquals(Math.E, Math.exp(1));
+assertEquals(Math.LN10, Math.log(10));
+assertEquals(Math.LN2, Math.log(2));
+assertEquals(Math.LOG10E, Math.log10(Math.E));
+assertEquals(Math.LOG2E, Math.log2(Math.E));
+assertEquals(Math.SQRT1_2, Math.sqrt(0.5));
+assertEquals(Math.SQRT2, Math.sqrt(2));
diff --git a/test/mjsunit/regress/regress-crbug-621816.js b/test/mjsunit/regress/regress-crbug-621816.js
new file mode 100644
index 0000000..ca7f5ac
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-621816.js
@@ -0,0 +1,18 @@
+// 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.
+
+// Flags: --allow-natives-syntax --turbo
+
+function f() {
+ var o = {};
+ o.a = 1;
+}
+function g() {
+ var o = { ['a']: function(){} };
+ f();
+}
+f();
+f();
+%OptimizeFunctionOnNextCall(g);
+g();
diff --git a/test/mjsunit/regress/regress-crbug-633585.js b/test/mjsunit/regress/regress-crbug-633585.js
new file mode 100644
index 0000000..c483e47
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-633585.js
@@ -0,0 +1,18 @@
+// 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.
+
+// Flags: --expose-gc --turbo --always-opt
+
+function f() { this.x = this.x.x; }
+gc();
+f.prototype.x = { x:1 }
+new f();
+new f();
+
+function g() {
+ function h() {};
+ h.prototype = { set x(value) { } };
+ new f();
+}
+g();
diff --git a/test/mjsunit/regress/regress-crbug-642056.js b/test/mjsunit/regress/regress-crbug-642056.js
new file mode 100644
index 0000000..ca9fc78
--- /dev/null
+++ b/test/mjsunit/regress/regress-crbug-642056.js
@@ -0,0 +1,17 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+function f(o) {
+ return o.x instanceof Array;
+}
+
+var o = { x : 1.5 };
+o.x = 0;
+
+f(o);
+f(o);
+%OptimizeFunctionOnNextCall(f);
+f(o);
diff --git a/test/mjsunit/regress/regress-put-prototype-transition.js b/test/mjsunit/regress/regress-put-prototype-transition.js
index 70f0074..c5b4c5a 100644
--- a/test/mjsunit/regress/regress-put-prototype-transition.js
+++ b/test/mjsunit/regress/regress-put-prototype-transition.js
@@ -30,7 +30,7 @@
__f_4(__v_1);
assertFalse(%HasFastProperties(__v_1));
__f_0(__v_1, __v_6);
- assertTrue(%HasFastProperties(__v_1));
+ assertFalse(%HasFastProperties(__v_1));
} else {
__f_0(__v_1, __v_6);
assertTrue(%HasFastProperties(__v_1));
diff --git a/test/mjsunit/regress/regress-seqstrsetchar-ex1.js b/test/mjsunit/regress/regress-seqstrsetchar-ex1.js
deleted file mode 100644
index 444fe4b..0000000
--- a/test/mjsunit/regress/regress-seqstrsetchar-ex1.js
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2013 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.
-
-// Flags: --allow-natives-syntax
-
-// stubbed version of ToNumber
-function ToNumber(x) {
- return 311;
-}
-
-// Reduced version of String.fromCharCode;
-// does not actually do the same calculation but exhibits untagging bug.
-function StringFromCharCode(code) {
- var n = arguments.length;
- var one_byte = %NewString(n, true);
- var i;
- for (i = 0; i < n; i++) {
- var code = arguments[i];
- if (!%_IsSmi(code)) code = ToNumber(code) & 0xffff;
- if (code > 0xff) break;
- }
-
- var two_byte = %NewString(n - i, false);
- for (var j = 0; i < n; i++, j++) {
- var code = arguments[i];
- %_TwoByteSeqStringSetChar(j, code, two_byte);
- }
- return one_byte + two_byte;
-}
-
-StringFromCharCode(0xFFF, 0xFFF);
-StringFromCharCode(0x7C, 0x7C);
-%OptimizeFunctionOnNextCall(StringFromCharCode);
-StringFromCharCode(0x7C, 0x7C);
-StringFromCharCode(0xFFF, 0xFFF);
diff --git a/test/mjsunit/regress/regress-seqstrsetchar-ex3.js b/test/mjsunit/regress/regress-seqstrsetchar-ex3.js
deleted file mode 100644
index 0a6b211..0000000
--- a/test/mjsunit/regress/regress-seqstrsetchar-ex3.js
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2013 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.
-
-// Flags: --allow-natives-syntax
-
-function test() {
- var string = %NewString(10, true);
- for (var i = 0; i < 10; i++) {
- %_OneByteSeqStringSetChar(i, 65, string);
- %_OneByteSeqStringSetChar(i, 66, string);
- }
- for (var i = 0; i < 10; i++) {
- assertEquals("B", string[i]);
- }
-}
-
-test();
-test();
-%OptimizeFunctionOnNextCall(test);
-test();
diff --git a/test/mjsunit/regress/regress-string-from-char-code-tonumber.js b/test/mjsunit/regress/regress-string-from-char-code-tonumber.js
new file mode 100644
index 0000000..a02a277
--- /dev/null
+++ b/test/mjsunit/regress/regress-string-from-char-code-tonumber.js
@@ -0,0 +1,26 @@
+// 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.
+
+// Flags: --allow-natives-syntax
+
+var thrower = { [Symbol.toPrimitive]: function() { FAIL } };
+
+function testTrace(func) {
+ try {
+ func(thrower);
+ assertUnreachable();
+ } catch (e) {
+ assertTrue(e.stack.indexOf("fromCharCode") >= 0);
+ }
+}
+
+testTrace(String.fromCharCode);
+
+function foo(x) { return String.fromCharCode(x); }
+
+foo(1);
+foo(2);
+testTrace(foo);
+%OptimizeFunctionOnNextCall(foo);
+testTrace(foo);
diff --git a/test/mjsunit/regress/regress-typedarray-length.js b/test/mjsunit/regress/regress-typedarray-length.js
index a0b9998..0dde61f 100644
--- a/test/mjsunit/regress/regress-typedarray-length.js
+++ b/test/mjsunit/regress/regress-typedarray-length.js
@@ -108,13 +108,13 @@
assertEquals("blah", get(a));
})();
-// Ensure we cannot delete length, byteOffset, byteLength.
+// Ensure we can delete length, byteOffset, byteLength.
assertTrue(Int32Array.prototype.__proto__.hasOwnProperty("length"));
assertTrue(Int32Array.prototype.__proto__.hasOwnProperty("byteOffset"));
assertTrue(Int32Array.prototype.__proto__.hasOwnProperty("byteLength"));
-assertFalse(delete Int32Array.prototype.__proto__.length);
-assertFalse(delete Int32Array.prototype.__proto__.byteOffset);
-assertFalse(delete Int32Array.prototype.__proto__.byteLength);
+assertTrue(delete Int32Array.prototype.__proto__.length);
+assertTrue(delete Int32Array.prototype.__proto__.byteOffset);
+assertTrue(delete Int32Array.prototype.__proto__.byteLength);
a = new Int32Array(100);
@@ -122,28 +122,28 @@
return a.length;
}
-assertEquals(100, get(a));
-assertEquals(100, get(a));
-assertEquals(100, get(a));
+assertEquals(undefined, get(a));
+assertEquals(undefined, get(a));
+assertEquals(undefined, get(a));
%OptimizeFunctionOnNextCall(get);
-assertEquals(100, get(a));
+assertEquals(undefined, get(a));
get = function(a) {
return a.byteLength;
}
-assertEquals(400, get(a));
-assertEquals(400, get(a));
-assertEquals(400, get(a));
+assertEquals(undefined, get(a));
+assertEquals(undefined, get(a));
+assertEquals(undefined, get(a));
%OptimizeFunctionOnNextCall(get);
-assertEquals(400, get(a));
+assertEquals(undefined, get(a));
get = function(a) {
return a.byteOffset;
}
-assertEquals(0, get(a));
-assertEquals(0, get(a));
-assertEquals(0, get(a));
+assertEquals(undefined, get(a));
+assertEquals(undefined, get(a));
+assertEquals(undefined, get(a));
%OptimizeFunctionOnNextCall(get);
-assertEquals(0, get(a));
+assertEquals(undefined, get(a));
diff --git a/test/mjsunit/regress/string-set-char-deopt.js b/test/mjsunit/regress/string-set-char-deopt.js
deleted file mode 100644
index 8956e28..0000000
--- a/test/mjsunit/regress/string-set-char-deopt.js
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2014 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.
-
-// Flags: --allow-natives-syntax
-
-(function OneByteSeqStringSetCharDeoptOsr() {
- function deopt() {
- %DeoptimizeFunction(f);
- }
-
- function f(string, osr) {
- var world = " world";
- %_OneByteSeqStringSetChar(0, (deopt(), 0x48), string);
-
- for (var i = 0; osr && i < 2; i++) %OptimizeOsr();
-
- return string + world;
- }
-
- assertEquals("Hello " + "world", f("hello", false));
- %OptimizeFunctionOnNextCall(f);
- assertEquals("Hello " + "world", f("hello", true));
-})();
-
-
-(function OneByteSeqStringSetCharDeopt() {
- function deopt() {
- %DeoptimizeFunction(f);
- }
-
- function g(x) {
- }
-
- function f(string) {
- g(%_OneByteSeqStringSetChar(0, (deopt(), 0x48), string));
- return string;
- }
-
- assertEquals("Hell" + "o", f("hello"));
- %OptimizeFunctionOnNextCall(f);
- assertEquals("Hell" + "o", f("hello"));
-})();
-
-
-(function TwoByteSeqStringSetCharDeopt() {
- function deopt() {
- %DeoptimizeFunction(f);
- }
-
- function g(x) {
- }
-
- function f(string) {
- g(%_TwoByteSeqStringSetChar(0, (deopt(), 0x48), string));
- return string;
- }
-
- assertEquals("Hell" + "o", f("\u20ACello"));
- %OptimizeFunctionOnNextCall(f);
- assertEquals("Hell" + "o", f("\u20ACello"));
-})();
diff --git a/test/mjsunit/string-natives.js b/test/mjsunit/string-natives.js
deleted file mode 100644
index 40fe9c6..0000000
--- a/test/mjsunit/string-natives.js
+++ /dev/null
@@ -1,79 +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.
-
-// Flags: --expose-gc --allow-natives-syntax
-
-function test() {
- var s1 = %NewString(26, true);
- for (i = 0; i < 26; i++) %_OneByteSeqStringSetChar(i, 65, s1);
- assertEquals("AAAAAAAAAAAAAAAAAAAAAAAAAA", s1);
- %_OneByteSeqStringSetChar(25, 66, s1);
- assertEquals("AAAAAAAAAAAAAAAAAAAAAAAAAB", s1);
- for (i = 0; i < 26; i++) %_OneByteSeqStringSetChar(i, i+65, s1);
- assertEquals("ABCDEFGHIJKLMNOPQRSTUVWXYZ", s1);
- s1 = %TruncateString(s1, 13);
- assertEquals("ABCDEFGHIJKLM", s1);
-
- var s2 = %NewString(26, false);
- for (i = 0; i < 26; i++) %_TwoByteSeqStringSetChar(i, 65, s2);
- assertEquals("AAAAAAAAAAAAAAAAAAAAAAAAAA", s2);
- %_TwoByteSeqStringSetChar(25, 66, s2);
- assertEquals("AAAAAAAAAAAAAAAAAAAAAAAAAB", s2);
- for (i = 0; i < 26; i++) %_TwoByteSeqStringSetChar(i, i+65, s2);
- assertEquals("ABCDEFGHIJKLMNOPQRSTUVWXYZ", s2);
- s2 = %TruncateString(s2, 13);
- assertEquals("ABCDEFGHIJKLM", s2);
-
- var s3 = %NewString(26, false);
- for (i = 0; i < 26; i++) %_TwoByteSeqStringSetChar(i, i+1000, s3);
- for (i = 0; i < 26; i++) assertEquals(s3[i], String.fromCharCode(i+1000));
-
- var a = [];
- for (var i = 0; i < 1000; i++) {
- var s = %NewString(10000, i % 2 == 1);
- a.push(s);
- }
-
- gc();
-
- for (var i = 0; i < 1000; i++) {
- assertEquals(10000, a[i].length);
- a[i] = %TruncateString(a[i], 5000);
- }
-
- gc();
-
- for (var i = 0; i < 1000; i++) {
- assertEquals(5000, a[i].length);
- }
-}
-
-
-test();
-test();
-%OptimizeFunctionOnNextCall(test);
-test();
diff --git a/test/mjsunit/tools/dumpcpp.js b/test/mjsunit/tools/dumpcpp.js
new file mode 100644
index 0000000..49b4675
--- /dev/null
+++ b/test/mjsunit/tools/dumpcpp.js
@@ -0,0 +1,53 @@
+// 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.
+
+// Load implementations from <project root>/tools.
+// Files: tools/splaytree.js tools/codemap.js tools/csvparser.js
+// Files: tools/consarray.js tools/profile.js tools/profile_view.js
+// Files: tools/logreader.js tools/tickprocessor.js
+// Files: tools/dumpcpp.js
+// Env: TEST_FILE_NAME
+
+(function testProcessSharedLibrary() {
+ var oldLoadSymbols = UnixCppEntriesProvider.prototype.loadSymbols;
+
+ UnixCppEntriesProvider.prototype.loadSymbols = function(libName) {
+ this.symbols = [[
+ '00000100 00000001 t v8::internal::Runtime_StringReplaceRegExpWithString(v8::internal::Arguments)',
+ '00000110 00000001 T v8::internal::Runtime::GetElementOrCharAt(v8::internal::Handle<v8::internal::Object>, unsigned int)',
+ '00000120 00000001 t v8::internal::Runtime_DebugGetPropertyDetails(v8::internal::Arguments)',
+ '00000130 00000001 W v8::internal::RegExpMacroAssembler::CheckPosition(int, v8::internal::Label*)'
+ ].join('\n'), ''];
+ };
+
+ var testCppProcessor = new CppProcessor(new UnixCppEntriesProvider(),
+ false, false);
+ testCppProcessor.processSharedLibrary(
+ '/usr/local/google/home/lpy/v8/out/native/d8',
+ 0x00000100, 0x00000400, 0);
+
+ var staticEntries = testCppProcessor.codeMap_.getAllStaticEntriesWithAddresses();
+ var total = staticEntries.length;
+ assertEquals(total, 3);
+ assertEquals(staticEntries[0],
+ [288,{size:1,
+ name:'v8::internal::Runtime_DebugGetPropertyDetails(v8::internal::Arguments)',
+ type:'CPP',
+ nameUpdated_:false}
+ ]);
+ assertEquals(staticEntries[1],
+ [272,{size:1,
+ name:'v8::internal::Runtime::GetElementOrCharAt(v8::internal::Handle<v8::internal::Object>, unsigned int)',
+ type:'CPP',
+ nameUpdated_:false}
+ ]);
+ assertEquals(staticEntries[2],
+ [256,{size:1,
+ name:'v8::internal::Runtime_StringReplaceRegExpWithString(v8::internal::Arguments)',
+ type:'CPP',
+ nameUpdated_:false}
+ ]);
+
+ UnixCppEntriesProvider.prototype.loadSymbols = oldLoadSymbols;
+})();
diff --git a/test/mjsunit/wasm/adapter-frame.js b/test/mjsunit/wasm/adapter-frame.js
index 39164c7..e595c3f 100644
--- a/test/mjsunit/wasm/adapter-frame.js
+++ b/test/mjsunit/wasm/adapter-frame.js
@@ -26,12 +26,9 @@
}
var builder = new WasmModuleBuilder();
- var sig = new Array();
- sig.push(args);
- for (var i = 0; i < args; i++) sig.push(type);
- sig.push(1);
- sig.push(type);
- builder.addFunction("select", sig)
+ var params = [];
+ for (var i = 0; i < args; i++) params.push(type);
+ builder.addFunction("select", makeSig(params, [type]))
.addBody([kExprGetLocal, which])
.exportFunc();
diff --git a/test/mjsunit/wasm/asm-wasm.js b/test/mjsunit/wasm/asm-wasm.js
index 54d7d7a..4c28b61 100644
--- a/test/mjsunit/wasm/asm-wasm.js
+++ b/test/mjsunit/wasm/asm-wasm.js
@@ -682,6 +682,7 @@
assertWasm(28, TestModDoubleNegative);
+
(function () {
function TestNamedFunctions() {
"use asm";
@@ -707,6 +708,7 @@
assertEquals(77.5, module.add());
})();
+
(function () {
function TestGlobalsWithInit() {
"use asm";
@@ -1358,6 +1360,38 @@
})();
+(function TestBadAssignDoubleFromIntish() {
+ function Module(stdlib, foreign, heap) {
+ "use asm";
+ function func() {
+ var a = 1;
+ var b = 3.0;
+ b = a;
+ }
+ return {func: func};
+ }
+ assertThrows(function() {
+ Wasm.instantiateModuleFromAsm(Module.toString());
+ });
+})();
+
+
+(function TestBadAssignIntFromDouble() {
+ function Module(stdlib, foreign, heap) {
+ "use asm";
+ function func() {
+ var a = 1;
+ var b = 3.0;
+ a = b;
+ }
+ return {func: func};
+ }
+ assertThrows(function() {
+ Wasm.instantiateModuleFromAsm(Module.toString());
+ });
+})();
+
+
(function TestBadMultiplyIntish() {
function Module(stdlib, foreign, heap) {
"use asm";
diff --git a/test/mjsunit/wasm/default-func-call.js b/test/mjsunit/wasm/default-func-call.js
new file mode 100644
index 0000000..14567d3
--- /dev/null
+++ b/test/mjsunit/wasm/default-func-call.js
@@ -0,0 +1,56 @@
+// 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.
+
+// Flags: --expose-wasm
+// Flags: --wasm-jit-prototype
+
+load("test/mjsunit/wasm/wasm-constants.js");
+load("test/mjsunit/wasm/wasm-module-builder.js");
+
+var module = (function () {
+ var builder = new WasmModuleBuilder();
+
+ var sig_index = builder.addType(kSig_i_ii);
+ builder.addPadFunctionTable(512);
+ builder.addImport("add", sig_index);
+ builder.addFunction("add", sig_index)
+ .addBody([
+ kExprGetLocal, 0, kExprGetLocal, 1, kExprCallImport, kArity2, 0
+ ]);
+ builder.addFunction("sub", sig_index)
+ .addBody([
+ kExprGetLocal, 0, // --
+ kExprGetLocal, 1, // --
+ kExprI32Sub, // --
+ ]);
+ builder.addFunction("main", kSig_i_iii)
+ .addBody([
+ kExprGetLocal, 0,
+ kExprGetLocal, 1,
+ kExprGetLocal, 2,
+ kExprCallIndirect, kArity2, sig_index
+ ])
+ .exportFunc()
+ builder.appendToTable([0, 1, 2]);
+
+ return builder.instantiate({add: function(a, b) { return a + b | 0; }});
+})();
+
+// Check the module exists.
+assertFalse(module === undefined);
+assertFalse(module === null);
+assertFalse(module === 0);
+assertEquals("object", typeof module.exports);
+assertEquals("function", typeof module.exports.main);
+
+assertEquals(5, module.exports.main(1, 12, 7));
+assertEquals(19, module.exports.main(0, 12, 7));
+
+assertTraps(kTrapFuncSigMismatch, "module.exports.main(2, 12, 33)");
+assertTraps(kTrapFuncSigMismatch, "module.exports.main(4, 12, 33)");
+assertTraps(kTrapFuncSigMismatch, "module.exports.main(511, 12, 33)");
+assertTraps(kTrapFuncInvalid, "module.exports.main(512, 12, 33)");
+assertTraps(kTrapFuncInvalid, "module.exports.main(1025, 12, 33)");
+assertTraps(kTrapFuncInvalid, "module.exports.main(-1, 12, 33)");
diff --git a/test/mjsunit/wasm/export-table.js b/test/mjsunit/wasm/export-table.js
index a41d85d..2084ddf 100644
--- a/test/mjsunit/wasm/export-table.js
+++ b/test/mjsunit/wasm/export-table.js
@@ -72,3 +72,18 @@
assertEquals(kReturnValue, module.exports["0"]());
})();
+
+(function testExportNameClash() {
+ var builder = new WasmModuleBuilder();
+
+ builder.addFunction("one", kSig_v_v).addBody([kExprNop]).exportAs("main");
+ builder.addFunction("two", kSig_v_v).addBody([kExprNop]).exportAs("other");
+ builder.addFunction("three", kSig_v_v).addBody([kExprNop]).exportAs("main");
+
+ try {
+ builder.instantiate();
+ assertUnreachable("should have thrown an exception");
+ } catch (e) {
+ assertContains("Duplicate export", e.toString());
+ }
+})();
diff --git a/test/mjsunit/wasm/ffi.js b/test/mjsunit/wasm/ffi.js
index 87dfe3b..9db8ea6 100644
--- a/test/mjsunit/wasm/ffi.js
+++ b/test/mjsunit/wasm/ffi.js
@@ -10,7 +10,7 @@
function testCallFFI(func, check) {
var builder = new WasmModuleBuilder();
- var sig_index = builder.addSignature(kSig_i_dd);
+ var sig_index = builder.addType(kSig_i_dd);
builder.addImport("func", sig_index);
builder.addFunction("main", sig_index)
.addBody([
diff --git a/test/mjsunit/wasm/function-names.js b/test/mjsunit/wasm/function-names.js
new file mode 100644
index 0000000..15771d8
--- /dev/null
+++ b/test/mjsunit/wasm/function-names.js
@@ -0,0 +1,69 @@
+// 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.
+
+// Flags: --expose-wasm
+
+load("test/mjsunit/wasm/wasm-constants.js");
+load("test/mjsunit/wasm/wasm-module-builder.js");
+
+var builder = new WasmModuleBuilder();
+
+var last_func_index = builder.addFunction("exec_unreachable", kSig_v_v)
+ .addBody([kExprUnreachable])
+
+var illegal_func_name = [0xff];
+var func_names = [ "☠", illegal_func_name, "some math: (½)² = ¼", "" ];
+var expected_names = ["exec_unreachable", "☠", null,
+ "some math: (½)² = ¼", "", "main"];
+
+for (var func_name of func_names) {
+ last_func_index = builder.addFunction(func_name, kSig_v_v)
+ .addBody([kExprCallFunction, kArity0, last_func_index]).index;
+}
+
+builder.addFunction("main", kSig_v_v)
+ .addBody([kExprCallFunction, kArity0, last_func_index])
+ .exportFunc();
+
+var module = builder.instantiate();
+
+(function testFunctionNamesAsString() {
+ var names = expected_names.concat(["testFunctionNamesAsString", null]);
+ try {
+ module.exports.main();
+ assertFalse("should throw");
+ } catch (e) {
+ var lines = e.stack.split(/\r?\n/);
+ lines.shift();
+ assertEquals(names.length, lines.length);
+ for (var i = 0; i < names.length; ++i) {
+ var line = lines[i].trim();
+ if (names[i] === null) continue;
+ var printed_name = names[i] === undefined ? "<WASM UNNAMED>" : names[i]
+ var expected_start = "at " + printed_name + " (";
+ assertTrue(line.startsWith(expected_start),
+ "should start with '" + expected_start + "': '" + line + "'");
+ }
+ }
+})();
+
+// For the remaining tests, collect the Callsite objects instead of just a
+// string:
+Error.prepareStackTrace = function(error, frames) {
+ return frames;
+};
+
+
+(function testFunctionNamesAsCallSites() {
+ var names = expected_names.concat(["testFunctionNamesAsCallSites", null]);
+ try {
+ module.exports.main();
+ assertFalse("should throw");
+ } catch (e) {
+ assertEquals(names.length, e.stack.length);
+ for (var i = 0; i < names.length; ++i) {
+ assertEquals(names[i], e.stack[i].getFunctionName());
+ }
+ }
+})();
diff --git a/test/mjsunit/wasm/gc-frame.js b/test/mjsunit/wasm/gc-frame.js
index 5fa9b05..9c37fe4 100644
--- a/test/mjsunit/wasm/gc-frame.js
+++ b/test/mjsunit/wasm/gc-frame.js
@@ -10,7 +10,7 @@
function makeFFI(func, t) {
var builder = new WasmModuleBuilder();
- var sig_index = builder.addSignature([10,t,t,t,t,t,t,t,t,t,t,1,t]);
+ var sig_index = builder.addType(makeSig([t,t,t,t,t,t,t,t,t,t], [t]));
builder.addImport("func", sig_index);
// Try to create a frame with lots of spilled values and parameters
// on the stack to try to catch GC bugs in the reference maps for
@@ -66,9 +66,32 @@
}
})();
-(function I32Test() {
+(function F64Test() {
var main = makeFFI(print10, kAstF64);
for (var i = 1; i < 2e+80; i *= -1137) {
main(i - 1, i, i + 2, i + 3, i + 4, i + 5, i + 6, i + 7, i + 8);
}
})();
+
+(function GCInJSToWasmTest() {
+ var builder = new WasmModuleBuilder();
+
+ var sig_index = builder.addType(kSig_i_i);
+ builder.addFunction("main", sig_index)
+ .addBody([
+ kExprGetLocal, 0, // --
+ ]) // --
+ .exportFunc();
+
+ var main = builder.instantiate({}).exports.main;
+
+ var gc_object = {
+ valueOf: function() {
+ // Call the GC in valueOf, which is called within the JSToWasm wrapper.
+ gc();
+ return {};
+ }
+ };
+
+ main(gc_object);
+})();
diff --git a/test/mjsunit/wasm/import-table.js b/test/mjsunit/wasm/import-table.js
index c3f8cb9..ebba040 100644
--- a/test/mjsunit/wasm/import-table.js
+++ b/test/mjsunit/wasm/import-table.js
@@ -10,7 +10,7 @@
function testCallImport(func, check) {
var builder = new WasmModuleBuilder();
- var sig_index = builder.addSignature(kSig_i_dd);
+ var sig_index = builder.addType(kSig_i_dd);
builder.addImport("func", sig_index);
builder.addFunction("main", sig_index)
.addBody([
diff --git a/test/mjsunit/wasm/indirect-calls.js b/test/mjsunit/wasm/indirect-calls.js
index 80bee41..1e87c6f 100644
--- a/test/mjsunit/wasm/indirect-calls.js
+++ b/test/mjsunit/wasm/indirect-calls.js
@@ -10,7 +10,7 @@
var module = (function () {
var builder = new WasmModuleBuilder();
- var sig_index = builder.addSignature(kSig_i_ii);
+ var sig_index = builder.addType(kSig_i_ii);
builder.addImport("add", sig_index);
builder.addFunction("add", sig_index)
.addBody([
@@ -30,7 +30,7 @@
kExprCallIndirect, kArity2, sig_index
])
.exportFunc()
- builder.appendToFunctionTable([0, 1, 2]);
+ builder.appendToTable([0, 1, 2]);
return builder.instantiate({add: function(a, b) { return a + b | 0; }});
})();
diff --git a/test/mjsunit/wasm/instantiate-module-basic.js b/test/mjsunit/wasm/instantiate-module-basic.js
index 800dcc1..72a3425 100644
--- a/test/mjsunit/wasm/instantiate-module-basic.js
+++ b/test/mjsunit/wasm/instantiate-module-basic.js
@@ -7,44 +7,54 @@
load("test/mjsunit/wasm/wasm-constants.js");
load("test/mjsunit/wasm/wasm-module-builder.js");
-var kReturnValue = 117;
+let kReturnValue = 117;
-var module = (function Build() {
- var builder = new WasmModuleBuilder();
-
+let buffer = (() => {
+ let builder = new WasmModuleBuilder();
builder.addMemory(1, 1, true);
builder.addFunction("main", kSig_i)
.addBody([kExprI8Const, kReturnValue])
.exportFunc();
- return builder.instantiate();
-})();
+ return builder.toBuffer();
+})()
-// Check the module exists.
-assertFalse(module === undefined);
-assertFalse(module === null);
-assertFalse(module === 0);
-assertEquals("object", typeof module);
+function CheckInstance(instance) {
+ assertFalse(instance === undefined);
+ assertFalse(instance === null);
+ assertFalse(instance === 0);
+ assertEquals("object", typeof instance);
-// Check the memory is an ArrayBuffer.
-var mem = module.exports.memory;
-assertFalse(mem === undefined);
-assertFalse(mem === null);
-assertFalse(mem === 0);
-assertEquals("object", typeof mem);
-assertTrue(mem instanceof ArrayBuffer);
-for (var i = 0; i < 4; i++) {
- module.exports.memory = 0; // should be ignored
- assertEquals(mem, module.exports.memory);
+ // Check the memory is an ArrayBuffer.
+ var mem = instance.exports.memory;
+ assertFalse(mem === undefined);
+ assertFalse(mem === null);
+ assertFalse(mem === 0);
+ assertEquals("object", typeof mem);
+ assertTrue(mem instanceof ArrayBuffer);
+ for (let i = 0; i < 4; i++) {
+ instance.exports.memory = 0; // should be ignored
+ assertSame(mem, instance.exports.memory);
+ }
+
+ assertEquals(65536, instance.exports.memory.byteLength);
+
+ // Check the properties of the main function.
+ let main = instance.exports.main;
+ assertFalse(main === undefined);
+ assertFalse(main === null);
+ assertFalse(main === 0);
+ assertEquals("function", typeof main);
+
+ assertEquals(kReturnValue, main());
}
-assertEquals(65536, module.exports.memory.byteLength);
+// Deprecated experimental API.
+CheckInstance(Wasm.instantiateModule(buffer));
-// Check the properties of the main function.
-var main = module.exports.main;
-assertFalse(main === undefined);
-assertFalse(main === null);
-assertFalse(main === 0);
-assertEquals("function", typeof main);
+// Official API
+let module = new WebAssembly.Module(buffer);
+CheckInstance(new WebAssembly.Instance(module));
-assertEquals(kReturnValue, main());
+let promise = WebAssembly.compile(buffer);
+promise.then(module => CheckInstance(new WebAssembly.Instance(module)));
diff --git a/test/mjsunit/wasm/params.js b/test/mjsunit/wasm/params.js
index 180ab1c..fe1b7d4 100644
--- a/test/mjsunit/wasm/params.js
+++ b/test/mjsunit/wasm/params.js
@@ -79,7 +79,7 @@
print("type = " + t + ", which = " + which);
var builder = new WasmModuleBuilder();
- builder.addFunction("select", [10,t,t,t,t,t,t,t,t,t,t,1,t])
+ builder.addFunction("select", makeSig([t,t,t,t,t,t,t,t,t,t], [t]))
.addBody([kExprGetLocal, which])
.exportFunc();
diff --git a/test/mjsunit/wasm/stack.js b/test/mjsunit/wasm/stack.js
index a45db94..4ff0d1d 100644
--- a/test/mjsunit/wasm/stack.js
+++ b/test/mjsunit/wasm/stack.js
@@ -16,10 +16,8 @@
function verifyStack(frames, expected) {
assertEquals(expected.length, frames.length, "number of frames mismatch");
expected.forEach(function(exp, i) {
- if (exp[1] != "?") {
- assertEquals(exp[1], frames[i].getFunctionName(),
- "["+i+"].getFunctionName()");
- }
+ assertEquals(exp[1], frames[i].getFunctionName(),
+ "["+i+"].getFunctionName()");
assertEquals(exp[2], frames[i].getLineNumber(), "["+i+"].getLineNumber()");
if (exp[0])
assertEquals(exp[3], frames[i].getPosition(),
@@ -27,8 +25,7 @@
assertContains(exp[4], frames[i].getFileName(), "["+i+"].getFileName()");
var toString;
if (exp[0]) {
- var funName = exp[1] == "?" ? "" : exp[1];
- toString = funName + " (<WASM>:" + exp[2] + ":" + exp[3] + ")";
+ toString = exp[1] + " (<WASM>[" + exp[2] + "]+" + exp[3] + ")";
} else {
toString = exp[4] + ":" + exp[2] + ":";
}
@@ -71,10 +68,10 @@
(function testSimpleStack() {
var expected_string = "Error\n" +
// The line numbers below will change as this test gains / loses lines..
- " at STACK (stack.js:42:11)\n" + // --
- " at main (<WASM>:0:1)\n" + // --
- " at testSimpleStack (stack.js:79:18)\n" + // --
- " at stack.js:81:3"; // --
+ " at STACK (stack.js:39:11)\n" + // --
+ " at main (<WASM>[0]+1)\n" + // --
+ " at testSimpleStack (stack.js:76:18)\n" + // --
+ " at stack.js:78:3"; // --
module.exports.main();
assertEquals(expected_string, stripPath(stack));
@@ -91,10 +88,10 @@
verifyStack(stack, [
// isWasm function line pos file
- [ false, "STACK", 42, 0, "stack.js"],
+ [ false, "STACK", 39, 0, "stack.js"],
[ true, "main", 0, 1, null],
- [ false, "testStackFrames", 90, 0, "stack.js"],
- [ false, null, 99, 0, "stack.js"]
+ [ false, "testStackFrames", 87, 0, "stack.js"],
+ [ false, null, 96, 0, "stack.js"]
]);
})();
@@ -107,8 +104,8 @@
verifyStack(e.stack, [
// isWasm function line pos file
[ true, "exec_unreachable", 1, 1, null],
- [ false, "testWasmUnreachable", 103, 0, "stack.js"],
- [ false, null, 114, 0, "stack.js"]
+ [ false, "testWasmUnreachable", 100, 0, "stack.js"],
+ [ false, null, 111, 0, "stack.js"]
]);
}
})();
@@ -121,10 +118,10 @@
assertContains("out of bounds", e.message);
verifyStack(e.stack, [
// isWasm function line pos file
- [ true, "?", 2, 3, null],
+ [ true, "", 2, 3, null],
[ true, "call_mem_out_of_bounds", 3, 1, null],
- [ false, "testWasmMemOutOfBounds", 118, 0, "stack.js"],
- [ false, null, 130, 0, "stack.js"]
+ [ false, "testWasmMemOutOfBounds", 115, 0, "stack.js"],
+ [ false, null, 127, 0, "stack.js"]
]);
}
})();
diff --git a/test/mjsunit/wasm/stackwalk.js b/test/mjsunit/wasm/stackwalk.js
index 5e5a1ef..913269f 100644
--- a/test/mjsunit/wasm/stackwalk.js
+++ b/test/mjsunit/wasm/stackwalk.js
@@ -10,7 +10,7 @@
function makeFFI(func) {
var builder = new WasmModuleBuilder();
- var sig_index = builder.addSignature(kSig_i_dd);
+ var sig_index = builder.addType(kSig_i_dd);
builder.addImport("func", sig_index);
builder.addFunction("main", sig_index)
.addBody([
diff --git a/test/mjsunit/wasm/start-function.js b/test/mjsunit/wasm/start-function.js
index 3c5707a..c4d299e 100644
--- a/test/mjsunit/wasm/start-function.js
+++ b/test/mjsunit/wasm/start-function.js
@@ -65,8 +65,8 @@
var func = builder.addFunction("", kSig_v_v)
.addBody([kExprNop]);
- builder.addExplicitSection([kDeclStartFunction, 0]);
- builder.addExplicitSection([kDeclStartFunction, 0]);
+ builder.addExplicitSection([kDeclStart, 0]);
+ builder.addExplicitSection([kDeclStart, 0]);
assertThrows(builder.instantiate);
})();
@@ -98,7 +98,7 @@
}};
var builder = new WasmModuleBuilder();
- var sig_index = builder.addSignature(kSig_v_v);
+ var sig_index = builder.addType(kSig_v_v);
builder.addImport("foo", sig_index);
var func = builder.addFunction("", sig_index)
diff --git a/test/mjsunit/wasm/test-wasm-module-builder.js b/test/mjsunit/wasm/test-wasm-module-builder.js
index 969b550..72d5a7a 100644
--- a/test/mjsunit/wasm/test-wasm-module-builder.js
+++ b/test/mjsunit/wasm/test-wasm-module-builder.js
@@ -91,7 +91,7 @@
.addBody([kExprGetLocal,
0, kExprGetLocal, 1, kExprGetLocal, 2, kExprCallIndirect, kArity2, 0])
.exportAs("main");
- module.appendToFunctionTable([0]);
+ module.appendToTable([0]);
var instance = module.instantiate();
assertEquals(44, instance.exports.main(0, 11, 33));
diff --git a/test/mjsunit/wasm/trap-location.js b/test/mjsunit/wasm/trap-location.js
index 5e3661d..0440af9 100644
--- a/test/mjsunit/wasm/trap-location.js
+++ b/test/mjsunit/wasm/trap-location.js
@@ -14,7 +14,7 @@
var builder = new WasmModuleBuilder();
-var sig_index = builder.addSignature(kSig_i_v)
+var sig_index = builder.addType(kSig_i_v)
// Build a function to resemble this code:
// if (idx < 2) {
diff --git a/test/mjsunit/wasm/wasm-constants.js b/test/mjsunit/wasm/wasm-constants.js
index 389383e..319cadc 100644
--- a/test/mjsunit/wasm/wasm-constants.js
+++ b/test/mjsunit/wasm/wasm-constants.js
@@ -52,18 +52,19 @@
// Section declaration constants
var kDeclMemory = 0x00;
-var kDeclSignatures = 0x01;
+var kDeclTypes = 0x01;
var kDeclFunctions = 0x02;
var kDeclGlobals = 0x03;
-var kDeclDataSegments = 0x04;
-var kDeclFunctionTable = 0x05;
+var kDeclData = 0x04;
+var kDeclTable = 0x05;
var kDeclEnd = 0x06;
-var kDeclStartFunction = 0x07;
-var kDeclImportTable = 0x08;
-var kDeclExportTable = 0x09;
-var kDeclFunctionSignatures = 0x0a;
-var kDeclFunctionBodies = 0x0b;
+var kDeclStart = 0x07;
+var kDeclImports = 0x08;
+var kDeclExports = 0x09;
+var kDeclFunctions = 0x0a;
+var kDeclCode = 0x0b;
var kDeclNames = 0x0c;
+var kDeclFunctionTablePad = 0x0d;
var kArity0 = 0;
var kArity1 = 1;
@@ -74,7 +75,7 @@
var section_names = [
"memory", "type", "old_function", "global", "data",
"table", "end", "start", "import", "export",
- "function", "code", "name"];
+ "function", "code", "name", "table_pad"];
// Function declaration flags
var kDeclFunctionName = 0x01;
@@ -90,31 +91,39 @@
var kAstF64 = 4;
// Useful signatures
-var kSig_i = [0, 1, kAstI32];
-var kSig_d = [0, 1, kAstF64];
-var kSig_i_i = [1, kAstI32, 1, kAstI32];
-var kSig_i_ii = [2, kAstI32, kAstI32, 1, kAstI32];
-var kSig_i_iii = [3, kAstI32, kAstI32, kAstI32, 1, kAstI32];
-var kSig_d_dd = [2, kAstF64, kAstF64, 1, kAstF64];
-var kSig_l_ll = [2, kAstI64, kAstI64, 1, kAstI64];
-var kSig_i_dd = [2, kAstF64, kAstF64, 1, kAstI32];
-var kSig_v_v = [0, 0];
-var kSig_i_v = [0, 1, kAstI32];
+var kSig_i = makeSig([], [kAstI32]);
+var kSig_d = makeSig([], [kAstF64]);
+var kSig_i_i = makeSig([kAstI32], [kAstI32]);
+var kSig_i_ii = makeSig([kAstI32, kAstI32], [kAstI32]);
+var kSig_i_iii = makeSig([kAstI32, kAstI32, kAstI32], [kAstI32]);
+var kSig_d_dd = makeSig([kAstF64, kAstF64], [kAstF64]);
+var kSig_l_ll = makeSig([kAstI64, kAstI64], [kAstI64]);
+var kSig_i_dd = makeSig([kAstF64, kAstF64], [kAstI32]);
+var kSig_v_v = makeSig([], []);
+var kSig_i_v = makeSig([], [kAstI32]);
-function makeSig_v_xx(x) {
- return [2, x, x, 0];
+function makeSig(params, results) {
+ return {params: params, results: results};
}
function makeSig_v_x(x) {
- return [1, x, 0];
+ return makeSig([x], []);
}
-function makeSig_r_xx(r, x) {
- return [2, x, x, 1, r];
+function makeSig_v_xx(x) {
+ return makeSig([x, x], []);
+}
+
+function makeSig_r_v(r) {
+ return makeSig([], [r]);
}
function makeSig_r_x(r, x) {
- return [1, x, 1, r];
+ return makeSig([x], [r]);
+}
+
+function makeSig_r_xx(r, x) {
+ return makeSig([x, x], [r]);
}
// Opcodes
diff --git a/test/mjsunit/wasm/wasm-module-builder.js b/test/mjsunit/wasm/wasm-module-builder.js
index bfc4460..5c5df79 100644
--- a/test/mjsunit/wasm/wasm-module-builder.js
+++ b/test/mjsunit/wasm/wasm-module-builder.js
@@ -2,351 +2,373 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-function WasmFunctionBuilder(name, sig_index) {
- this.name = name;
- this.sig_index = sig_index;
- this.exports = [];
-}
+class Binary extends Array {
+ emit_u8(val) {
+ this.push(val);
+ }
-WasmFunctionBuilder.prototype.exportAs = function(name) {
- this.exports.push(name);
- return this;
-}
+ emit_u16(val) {
+ this.push(val & 0xff);
+ this.push((val >> 8) & 0xff);
+ }
-WasmFunctionBuilder.prototype.exportFunc = function() {
- this.exports.push(this.name);
- return this;
-}
+ emit_u32(val) {
+ this.push(val & 0xff);
+ this.push((val >> 8) & 0xff);
+ this.push((val >> 16) & 0xff);
+ this.push((val >> 24) & 0xff);
+ }
-WasmFunctionBuilder.prototype.addBody = function(body) {
- this.body = body;
- return this;
-}
+ emit_varint(val) {
+ while (true) {
+ let v = val & 0xff;
+ val = val >>> 7;
+ if (val == 0) {
+ this.push(v);
+ break;
+ }
+ this.push(v | 0x80);
+ }
+ }
-WasmFunctionBuilder.prototype.addLocals = function(locals) {
- this.locals = locals;
- return this;
-}
+ emit_bytes(data) {
+ for (let i = 0; i < data.length; i++) {
+ this.push(data[i] & 0xff);
+ }
+ }
-function WasmModuleBuilder() {
- this.signatures = [];
- this.imports = [];
- this.functions = [];
- this.exports = [];
- this.function_table = [];
- this.data_segments = [];
- this.explicit = [];
- return this;
-}
-
-WasmModuleBuilder.prototype.addStart = function(start_index) {
- this.start_index = start_index;
-}
-
-WasmModuleBuilder.prototype.addMemory = function(min, max, exp) {
- this.memory = {min: min, max: max, exp: exp};
- return this;
-}
-
-WasmModuleBuilder.prototype.addExplicitSection = function(bytes) {
- this.explicit.push(bytes);
- return this;
-}
-
-// Add a signature; format is [param_count, param0, param1, ..., retcount, ret0]
-WasmModuleBuilder.prototype.addSignature = function(sig) {
- // TODO: canonicalize signatures?
- this.signatures.push(sig);
- return this.signatures.length - 1;
-}
-
-WasmModuleBuilder.prototype.addFunction = function(name, sig) {
- var sig_index = (typeof sig) == "number" ? sig : this.addSignature(sig);
- var func = new WasmFunctionBuilder(name, sig_index);
- func.index = this.functions.length;
- this.functions.push(func);
- return func;
-}
-
-WasmModuleBuilder.prototype.addImportWithModule = function(module, name, sig) {
- var sig_index = (typeof sig) == "number" ? sig : this.addSignature(sig);
- this.imports.push({module: module, name: name, sig_index: sig_index});
- return this.imports.length - 1;
-}
-
-WasmModuleBuilder.prototype.addImport = function(name, sig) {
- this.addImportWithModule(name, undefined, sig);
-}
-
-WasmModuleBuilder.prototype.addDataSegment = function(addr, data, init) {
- this.data_segments.push({addr: addr, data: data, init: init});
- return this.data_segments.length - 1;
-}
-
-WasmModuleBuilder.prototype.appendToFunctionTable = function(array) {
- this.function_table = this.function_table.concat(array);
- return this;
-}
-
-function emit_u8(bytes, val) {
- bytes.push(val & 0xff);
-}
-
-function emit_u16(bytes, val) {
- bytes.push(val & 0xff);
- bytes.push((val >> 8) & 0xff);
-}
-
-function emit_u32(bytes, val) {
- bytes.push(val & 0xff);
- bytes.push((val >> 8) & 0xff);
- bytes.push((val >> 16) & 0xff);
- bytes.push((val >> 24) & 0xff);
-}
-
-function emit_string(bytes, string) {
+ emit_string(string) {
// When testing illegal names, we pass a byte array directly.
if (string instanceof Array) {
- emit_varint(bytes, string.length);
- emit_bytes(bytes, string);
+ this.emit_varint(string.length);
+ this.emit_bytes(string);
return;
}
- // This is the hacky way to convert a JavaScript scring to a UTF8 encoded
+ // This is the hacky way to convert a JavaScript string to a UTF8 encoded
// string only containing single-byte characters.
- var string_utf8 = unescape(encodeURIComponent(string));
- emit_varint(bytes, string_utf8.length);
- for (var i = 0; i < string_utf8.length; i++) {
- emit_u8(bytes, string_utf8.charCodeAt(i));
+ let string_utf8 = unescape(encodeURIComponent(string));
+ this.emit_varint(string_utf8.length);
+ for (let i = 0; i < string_utf8.length; i++) {
+ this.emit_u8(string_utf8.charCodeAt(i));
}
-}
+ }
-function emit_varint(bytes, val) {
- while (true) {
- var v = val & 0xff;
- val = val >>> 7;
- if (val == 0) {
- bytes.push(v);
- break;
- }
- bytes.push(v | 0x80);
- }
-}
+ emit_header() {
+ this.push(kWasmH0, kWasmH1, kWasmH2, kWasmH3,
+ kWasmV0, kWasmV1, kWasmV2, kWasmV3);
+ }
-function emit_bytes(bytes, data) {
- for (var i = 0; i < data.length; i++) {
- bytes.push(data[i] & 0xff);
+ emit_section(section_code, content_generator) {
+ // Emit section name.
+ this.emit_string(section_names[section_code]);
+ // Emit the section to a temporary buffer: its full length isn't know yet.
+ let section = new Binary;
+ content_generator(section);
+ // Emit section length.
+ this.emit_varint(section.length);
+ // Copy the temporary buffer.
+ this.push(...section);
}
}
-function emit_section(bytes, section_code, content_generator) {
- // Emit section name.
- emit_string(bytes, section_names[section_code]);
- // Emit the section to a temporary buffer: its full length isn't know yet.
- var tmp_bytes = [];
- content_generator(tmp_bytes);
- // Emit section length.
- emit_varint(bytes, tmp_bytes.length);
- // Copy the temporary buffer.
- Array.prototype.push.apply(bytes, tmp_bytes);
+class WasmFunctionBuilder {
+ constructor(name, type_index) {
+ this.name = name;
+ this.type_index = type_index;
+ this.exports = [];
+ }
+
+ exportAs(name) {
+ this.exports.push(name);
+ return this;
+ }
+
+ exportFunc() {
+ this.exports.push(this.name);
+ return this;
+ }
+
+ addBody(body) {
+ this.body = body;
+ return this;
+ }
+
+ addLocals(locals) {
+ this.locals = locals;
+ return this;
+ }
}
-WasmModuleBuilder.prototype.toArray = function(debug) {
- // Add header bytes
- var bytes = [];
- bytes = bytes.concat([kWasmH0, kWasmH1, kWasmH2, kWasmH3,
- kWasmV0, kWasmV1, kWasmV2, kWasmV3]);
+class WasmModuleBuilder {
+ constructor() {
+ this.types = [];
+ this.imports = [];
+ this.functions = [];
+ this.exports = [];
+ this.table = [];
+ this.segments = [];
+ this.explicit = [];
+ this.pad = null;
+ return this;
+ }
- var wasm = this;
+ addStart(start_index) {
+ this.start_index = start_index;
+ }
- // Add signatures section
- if (wasm.signatures.length > 0) {
- if (debug) print("emitting signatures @ " + bytes.length);
- emit_section(bytes, kDeclSignatures, function(bytes) {
- emit_varint(bytes, wasm.signatures.length);
- for (sig of wasm.signatures) {
- emit_u8(bytes, kWasmFunctionTypeForm);
- for (var j = 0; j < sig.length; j++) {
- emit_u8(bytes, sig[j]);
- }
- }
- });
+ addMemory(min, max, exp) {
+ this.memory = {min: min, max: max, exp: exp};
+ return this;
+ }
+
+ addPadFunctionTable(size) {
+ this.pad = size;
+ return this;
+ }
+
+ addExplicitSection(bytes) {
+ this.explicit.push(bytes);
+ return this;
+ }
+
+ addType(type) {
+ // TODO: canonicalize types?
+ this.types.push(type);
+ return this.types.length - 1;
+ }
+
+ addFunction(name, type) {
+ let type_index = (typeof type) == "number" ? type : this.addType(type);
+ let func = new WasmFunctionBuilder(name, type_index);
+ func.index = this.functions.length;
+ this.functions.push(func);
+ return func;
+ }
+
+ addImportWithModule(module, name, type) {
+ let type_index = (typeof type) == "number" ? type : this.addType(type);
+ this.imports.push({module: module, name: name, type: type_index});
+ return this.imports.length - 1;
+ }
+
+ addImport(name, type) {
+ return this.addImportWithModule(name, undefined, type);
+ }
+
+ addDataSegment(addr, data, init) {
+ this.segments.push({addr: addr, data: data, init: init});
+ return this.segments.length - 1;
+ }
+
+ appendToTable(array) {
+ this.table.push(...array);
+ return this;
+ }
+
+ toArray(debug) {
+ let binary = new Binary;
+ let wasm = this;
+
+ // Add header
+ binary.emit_header();
+
+ // Add type section
+ if (wasm.types.length > 0) {
+ if (debug) print("emitting types @ " + binary.length);
+ binary.emit_section(kDeclTypes, section => {
+ section.emit_varint(wasm.types.length);
+ for (let type of wasm.types) {
+ section.emit_u8(kWasmFunctionTypeForm);
+ section.emit_varint(type.params.length);
+ for (let param of type.params) {
+ section.emit_u8(param);
+ }
+ section.emit_varint(type.results.length);
+ for (let result of type.results) {
+ section.emit_u8(result);
+ }
+ }
+ });
}
// Add imports section
if (wasm.imports.length > 0) {
- if (debug) print("emitting imports @ " + bytes.length);
- emit_section(bytes, kDeclImportTable, function(bytes) {
- emit_varint(bytes, wasm.imports.length);
- for (imp of wasm.imports) {
- emit_varint(bytes, imp.sig_index);
- emit_string(bytes, imp.module);
- emit_string(bytes, imp.name || '');
- }
- });
+ if (debug) print("emitting imports @ " + binary.length);
+ binary.emit_section(kDeclImports, section => {
+ section.emit_varint(wasm.imports.length);
+ for (let imp of wasm.imports) {
+ section.emit_varint(imp.type);
+ section.emit_string(imp.module);
+ section.emit_string(imp.name || '');
+ }
+ });
}
// Add functions declarations
- var names = false;
- var exports = 0;
+ let has_names = false;
+ let names = false;
+ let exports = 0;
if (wasm.functions.length > 0) {
- var has_names = false;
-
- // emit function signatures
- if (debug) print("emitting function sigs @ " + bytes.length);
- emit_section(bytes, kDeclFunctionSignatures, function(bytes) {
- emit_varint(bytes, wasm.functions.length);
- for (func of wasm.functions) {
- has_names = has_names || (func.name != undefined &&
- func.name.length > 0);
- exports += func.exports.length;
-
- emit_varint(bytes, func.sig_index);
- }
- });
-
+ if (debug) print("emitting function decls @ " + binary.length);
+ binary.emit_section(kDeclFunctions, section => {
+ section.emit_varint(wasm.functions.length);
+ for (let func of wasm.functions) {
+ has_names = has_names || (func.name != undefined &&
+ func.name.length > 0);
+ exports += func.exports.length;
+ section.emit_varint(func.type_index);
+ }
+ });
}
- // Add function table.
- if (wasm.function_table.length > 0) {
- if (debug) print("emitting function table @ " + bytes.length);
- emit_section(bytes, kDeclFunctionTable, function(bytes) {
- emit_varint(bytes, wasm.function_table.length);
- for (index of wasm.function_table) {
- emit_varint(bytes, index);
- }
- });
+ // Add table.
+ if (wasm.table.length > 0) {
+ if (debug) print("emitting table @ " + binary.length);
+ binary.emit_section(kDeclTable, section => {
+ section.emit_varint(wasm.table.length);
+ for (let index of wasm.table) {
+ section.emit_varint(index);
+ }
+ });
}
// Add memory section
if (wasm.memory != undefined) {
- if (debug) print("emitting memory @ " + bytes.length);
- emit_section(bytes, kDeclMemory, function(bytes) {
- emit_varint(bytes, wasm.memory.min);
- emit_varint(bytes, wasm.memory.max);
- emit_u8(bytes, wasm.memory.exp ? 1 : 0);
- });
+ if (debug) print("emitting memory @ " + binary.length);
+ binary.emit_section(kDeclMemory, section => {
+ section.emit_varint(wasm.memory.min);
+ section.emit_varint(wasm.memory.max);
+ section.emit_u8(wasm.memory.exp ? 1 : 0);
+ });
}
// Add export table.
if (exports > 0) {
- if (debug) print("emitting exports @ " + bytes.length);
- emit_section(bytes, kDeclExportTable, function(bytes) {
- emit_varint(bytes, exports);
- for (func of wasm.functions) {
- for (exp of func.exports) {
- emit_varint(bytes, func.index);
- emit_string(bytes, exp);
- }
- }
- });
+ if (debug) print("emitting exports @ " + binary.length);
+ binary.emit_section(kDeclExports, section => {
+ section.emit_varint(exports);
+ for (let func of wasm.functions) {
+ for (let exp of func.exports) {
+ section.emit_varint(func.index);
+ section.emit_string(exp);
+ }
+ }
+ });
}
// Add start function section.
if (wasm.start_index != undefined) {
- if (debug) print("emitting start function @ " + bytes.length);
- emit_section(bytes, kDeclStartFunction, function(bytes) {
- emit_varint(bytes, wasm.start_index);
- });
+ if (debug) print("emitting start function @ " + binary.length);
+ binary.emit_section(kDeclStart, section => {
+ section.emit_varint(wasm.start_index);
+ });
}
// Add function bodies.
if (wasm.functions.length > 0) {
- // emit function bodies
- if (debug) print("emitting function bodies @ " + bytes.length);
- emit_section(bytes, kDeclFunctionBodies, function(bytes) {
- emit_varint(bytes, wasm.functions.length);
- for (func of wasm.functions) {
- // Function body length will be patched later.
- var local_decls = [];
- var l = func.locals;
- if (l != undefined) {
- var local_decls_count = 0;
- if (l.i32_count > 0) {
- local_decls.push({count: l.i32_count, type: kAstI32});
- }
- if (l.i64_count > 0) {
- local_decls.push({count: l.i64_count, type: kAstI64});
- }
- if (l.f32_count > 0) {
- local_decls.push({count: l.f32_count, type: kAstF32});
- }
- if (l.f64_count > 0) {
- local_decls.push({count: l.f64_count, type: kAstF64});
- }
- }
- var header = new Array();
-
- emit_varint(header, local_decls.length);
- for (decl of local_decls) {
- emit_varint(header, decl.count);
- emit_u8(header, decl.type);
- }
-
- emit_varint(bytes, header.length + func.body.length);
- emit_bytes(bytes, header);
- emit_bytes(bytes, func.body);
+ // emit function bodies
+ if (debug) print("emitting code @ " + binary.length);
+ binary.emit_section(kDeclCode, section => {
+ section.emit_varint(wasm.functions.length);
+ for (let func of wasm.functions) {
+ // Function body length will be patched later.
+ let local_decls = [];
+ let l = func.locals;
+ if (l != undefined) {
+ let local_decls_count = 0;
+ if (l.i32_count > 0) {
+ local_decls.push({count: l.i32_count, type: kAstI32});
}
- });
+ if (l.i64_count > 0) {
+ local_decls.push({count: l.i64_count, type: kAstI64});
+ }
+ if (l.f32_count > 0) {
+ local_decls.push({count: l.f32_count, type: kAstF32});
+ }
+ if (l.f64_count > 0) {
+ local_decls.push({count: l.f64_count, type: kAstF64});
+ }
+ }
+
+ let header = new Binary;
+ header.emit_varint(local_decls.length);
+ for (let decl of local_decls) {
+ header.emit_varint(decl.count);
+ header.emit_u8(decl.type);
+ }
+
+ section.emit_varint(header.length + func.body.length);
+ section.emit_bytes(header);
+ section.emit_bytes(func.body);
+ }
+ });
}
// Add data segments.
- if (wasm.data_segments.length > 0) {
- if (debug) print("emitting data segments @ " + bytes.length);
- emit_section(bytes, kDeclDataSegments, function(bytes) {
- emit_varint(bytes, wasm.data_segments.length);
- for (seg of wasm.data_segments) {
- emit_varint(bytes, seg.addr);
- emit_varint(bytes, seg.data.length);
- emit_bytes(bytes, seg.data);
- }
- });
+ if (wasm.segments.length > 0) {
+ if (debug) print("emitting data segments @ " + binary.length);
+ binary.emit_section(kDeclData, section => {
+ section.emit_varint(wasm.segments.length);
+ for (let seg of wasm.segments) {
+ section.emit_varint(seg.addr);
+ section.emit_varint(seg.data.length);
+ section.emit_bytes(seg.data);
+ }
+ });
}
// Add any explicitly added sections
- for (exp of wasm.explicit) {
- if (debug) print("emitting explicit @ " + bytes.length);
- emit_bytes(bytes, exp);
+ for (let exp of wasm.explicit) {
+ if (debug) print("emitting explicit @ " + binary.length);
+ binary.emit_bytes(exp);
}
// Add function names.
if (has_names) {
- if (debug) print("emitting names @ " + bytes.length);
- emit_section(bytes, kDeclNames, function(bytes) {
- emit_varint(bytes, wasm.functions.length);
- for (func of wasm.functions) {
- var name = func.name == undefined ? "" : func.name;
- emit_string(bytes, name);
- emit_u8(bytes, 0); // local names count == 0
- }
- });
+ if (debug) print("emitting names @ " + binary.length);
+ binary.emit_section(kDeclNames, section => {
+ section.emit_varint(wasm.functions.length);
+ for (let func of wasm.functions) {
+ var name = func.name == undefined ? "" : func.name;
+ section.emit_string(name);
+ section.emit_u8(0); // local names count == 0
+ }
+ });
+ }
+
+ // Add an indirect function table pad section.
+ if (wasm.pad !== null) {
+ if (debug)
+ print("emitting indirect function table pad @ " + binary.length);
+ binary.emit_section(kDeclFunctionTablePad, section => {
+ section.emit_varint(wasm.pad);
+ });
}
// End the module.
- if (debug) print("emitting end @ " + bytes.length);
- emit_section(bytes, kDeclEnd, function(bytes) {});
+ if (debug) print("emitting end @ " + binary.length);
+ binary.emit_section(kDeclEnd, section => {});
- return bytes;
-}
+ return binary;
+ }
-WasmModuleBuilder.prototype.toBuffer = function(debug) {
- var bytes = this.toArray(debug);
- var buffer = new ArrayBuffer(bytes.length);
- var view = new Uint8Array(buffer);
- for (var i = 0; i < bytes.length; i++) {
- var val = bytes[i];
- if ((typeof val) == "string") val = val.charCodeAt(0);
- view[i] = val | 0;
+ toBuffer(debug) {
+ let bytes = this.toArray(debug);
+ let buffer = new ArrayBuffer(bytes.length);
+ let view = new Uint8Array(buffer);
+ for (let i = 0; i < bytes.length; i++) {
+ let val = bytes[i];
+ if ((typeof val) == "string") val = val.charCodeAt(0);
+ view[i] = val | 0;
}
return buffer;
-}
+ }
-WasmModuleBuilder.prototype.instantiate = function(ffi, memory) {
- var buffer = this.toBuffer();
- if (memory != undefined) {
- return Wasm.instantiateModule(buffer, ffi, memory);
- } else {
- return Wasm.instantiateModule(buffer, ffi);
- }
+ instantiate(...args) {
+ let module = new WebAssembly.Module(this.toBuffer());
+ let instance = new WebAssembly.Instance(module, ...args);
+ return instance;
+ }
}
diff --git a/test/mjsunit/wasm/wasm-object-api.js b/test/mjsunit/wasm/wasm-object-api.js
index 96088b8..510b571 100644
--- a/test/mjsunit/wasm/wasm-object-api.js
+++ b/test/mjsunit/wasm/wasm-object-api.js
@@ -11,3 +11,8 @@
assertEquals("function", typeof Wasm.instantiateModule);
assertEquals("function", typeof Wasm.instantiateModuleFromAsm);
assertFalse(undefined == Wasm.experimentalVersion);
+
+assertEquals('object', typeof WebAssembly);
+assertEquals('function', typeof WebAssembly.Module);
+assertEquals('function', typeof WebAssembly.Instance);
+assertEquals('function', typeof WebAssembly.compile);
diff --git a/test/test262/BUILD.gn b/test/test262/BUILD.gn
new file mode 100644
index 0000000..9aaa777
--- /dev/null
+++ b/test/test262/BUILD.gn
@@ -0,0 +1,34 @@
+# 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.
+
+import("../../gni/isolate.gni")
+
+if (v8_test_isolation_mode != "noop") {
+ action("archive_test262") {
+ visibility = [ ":*" ]
+
+ script = "archive.py"
+
+ inputs = [
+ "list.py",
+ ]
+
+ sources = exec_script("list.py", [], "list lines")
+
+ outputs = [
+ "$target_gen_dir/test262_archiving.stamp",
+ ]
+
+ args = rebase_path(outputs, root_build_dir)
+ }
+}
+
+v8_isolate_run("test262") {
+ deps = [
+ ":archive_test262",
+ "../..:d8_run",
+ ]
+
+ isolate = "test262.isolate"
+}
diff --git a/test/test262/archive.py b/test/test262/archive.py
index c265b32..9a52d6c 100755
--- a/test/test262/archive.py
+++ b/test/test262/archive.py
@@ -4,7 +4,13 @@
# found in the LICENSE file.
import os
+import sys
import tarfile
+import time
+
+# In GN we expect the path to a stamp file as an argument.
+if len(sys.argv) == 2:
+ STAMP_FILE = os.path.abspath(sys.argv[1])
os.chdir(os.path.dirname(os.path.abspath(__file__)))
@@ -21,3 +27,10 @@
with tarfile.open('data.tar', 'w') as tar:
tar.add('data', filter=filter_git)
+
+# Workaround for GN. We can't specify the tarfile as output because it's
+# not in the product directory. Therefore we track running of this script
+# with an extra stamp file in the product directory.
+if len(sys.argv) == 2:
+ with open(STAMP_FILE, 'w') as f:
+ f.write(str(time.time()))
diff --git a/test/test262/test262.status b/test/test262/test262.status
index 27b56d4..2933e15 100644
--- a/test/test262/test262.status
+++ b/test/test262/test262.status
@@ -71,6 +71,10 @@
'language/expressions/assignment/S11.13.1_A6*': [FAIL],
# https://bugs.chromium.org/p/v8/issues/detail?id=4709
+ 'built-ins/Promise/reject-function-name': [FAIL],
+ 'built-ins/Promise/resolve-function-name': [FAIL],
+ 'built-ins/Promise/all/resolve-element-function-name': [FAIL],
+ 'built-ins/Promise/executor-function-name': [FAIL],
'built-ins/Proxy/revocable/revocation-function-name': [FAIL],
'language/expressions/assignment/fn-name-lhs-cover': [FAIL],
'language/expressions/assignment/fn-name-lhs-member': [FAIL],
@@ -100,28 +104,8 @@
'language/asi/S7.9_A5.7_T1': [PASS, FAIL_OK],
###### BEGIN REGEXP SUBCLASSING SECTION ######
- # Spec change in progress https://github.com/tc39/ecma262/pull/494
- # RegExpBuiltinMatch reads flags from [[OriginalFlags]]
- 'built-ins/RegExp/prototype/Symbol.match/builtin-coerce-sticky': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.match/builtin-get-global-err': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.match/builtin-get-sticky-err': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.match/builtin-success-g-set-lastindex': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.match/builtin-success-g-set-lastindex-err': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.match/coerce-sticky': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.match/get-sticky-err': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.replace/coerce-global': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.replace/coerce-unicode': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.replace/get-sticky-coerce': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.replace/get-sticky-err': [SKIP],
- 'built-ins/RegExp/prototype/Symbol.search/get-sticky-coerce': [FAIL],
- 'built-ins/RegExp/prototype/Symbol.search/get-sticky-err': [FAIL],
- 'built-ins/RegExp/prototype/exec/get-sticky-coerce': [FAIL],
- 'built-ins/RegExp/prototype/exec/get-sticky-err': [FAIL],
- 'built-ins/RegExp/prototype/test/get-sticky-err': [FAIL],
-
# Times out
'built-ins/RegExp/prototype/Symbol.match/coerce-global': [SKIP],
- 'built-ins/RegExp/prototype/Symbol.match/builtin-coerce-global': [SKIP],
# Sticky support busted
'built-ins/RegExp/prototype/Symbol.replace/y-init-lastindex': [FAIL],
@@ -131,6 +115,7 @@
# https://bugs.chromium.org/p/chromium/issues/detail?id=624318
'built-ins/RegExp/prototype/Symbol.match/builtin-failure-set-lastindex-err': [PASS, FAIL],
'built-ins/RegExp/prototype/Symbol.match/builtin-failure-y-set-lastindex-err': [PASS, FAIL],
+ 'built-ins/RegExp/prototype/Symbol.match/builtin-success-g-set-lastindex-err': [SKIP],
'built-ins/RegExp/prototype/Symbol.match/builtin-success-y-set-lastindex-err': [PASS, FAIL],
'built-ins/RegExp/prototype/Symbol.match/g-init-lastindex-err': [PASS, FAIL],
'built-ins/RegExp/prototype/Symbol.match/g-match-empty-set-lastindex-err': [PASS, FAIL],
@@ -146,6 +131,10 @@
# happens to be thrown for some other reason.
'built-ins/RegExp/prototype/Symbol.split/str-result-get-length-err': [SKIP],
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5123
+ 'built-ins/RegExp/prototype/Symbol.replace/coerce-global': [FAIL],
+ 'built-ins/RegExp/prototype/Symbol.replace/coerce-unicode': [FAIL],
+
###### END REGEXP SUBCLASSING SECTION ######
# https://code.google.com/p/v8/issues/detail?id=4360
@@ -153,67 +142,12 @@
'intl402/DateTimeFormat/12.1.1_1': [FAIL],
'intl402/NumberFormat/11.1.1_1': [FAIL],
- # https://code.google.com/p/v8/issues/detail?id=4476
- # The bug is fixed but behind a flag, --icu_case_mapping.
- 'built-ins/String/prototype/toLowerCase/special_casing_conditional': [FAIL],
- 'built-ins/String/prototype/toLowerCase/supplementary_plane': [FAIL],
- 'built-ins/String/prototype/toUpperCase/supplementary_plane': [FAIL],
-
- # https://code.google.com/p/v8/issues/detail?id=4477
- # The bug is fixed but behind a flag, --icu_case_mapping.
- 'built-ins/String/prototype/toLocaleUpperCase/supplementary_plane': [FAIL],
- 'built-ins/String/prototype/toLocaleLowerCase/supplementary_plane': [FAIL],
- 'built-ins/String/prototype/toLocaleLowerCase/special_casing_conditional': [FAIL],
- 'intl402/String/prototype/toLocaleLowerCase/special_casing_Azeri': [FAIL],
- 'intl402/String/prototype/toLocaleLowerCase/special_casing_Lithuanian': [FAIL],
- 'intl402/String/prototype/toLocaleLowerCase/special_casing_Turkish': [FAIL],
- 'intl402/String/prototype/toLocaleUpperCase/special_casing_Azeri': [FAIL],
- 'intl402/String/prototype/toLocaleUpperCase/special_casing_Lithuanian': [FAIL],
- 'intl402/String/prototype/toLocaleUpperCase/special_casing_Turkish': [FAIL],
-
- # https://bugs.chromium.org/p/v8/issues/detail?id=4628
- 'language/eval-code/non-definable-function-with-variable': [FAIL],
- 'language/eval-code/non-definable-function-with-function': [FAIL],
-
- # https://bugs.chromium.org/p/v8/issues/detail?id=4592
- 'built-ins/ArrayBuffer/length-is-absent': [FAIL],
- 'built-ins/ArrayBuffer/length-is-not-number': [FAIL],
- 'built-ins/ArrayBuffer/positive-integer-length': [FAIL],
- 'language/statements/class/subclass/builtin-objects/ArrayBuffer/regular-subclassing': [FAIL],
-
- # https://bugs.chromium.org/p/v8/issues/detail?id=4633
- 'built-ins/Promise/reject-function-name': [FAIL],
- 'built-ins/Promise/resolve-function-name': [FAIL],
- 'built-ins/Promise/all/resolve-element-function-name': [FAIL],
- 'built-ins/Promise/executor-function-name': [FAIL],
-
- # https://bugs.chromium.org/p/v8/issues/detail?id=4634
- 'built-ins/DataView/prototype/setFloat64/index-check-before-value-conversion': [FAIL],
- 'built-ins/DataView/prototype/setFloat32/index-check-before-value-conversion': [FAIL],
- 'built-ins/DataView/prototype/setInt16/index-check-before-value-conversion': [FAIL],
- 'built-ins/DataView/prototype/setInt32/index-check-before-value-conversion': [FAIL],
- 'built-ins/DataView/prototype/setUint16/index-check-before-value-conversion': [FAIL],
- 'built-ins/DataView/prototype/setUint32/index-check-before-value-conversion': [FAIL],
- 'built-ins/DataView/prototype/setUint8/index-check-before-value-conversion': [FAIL],
- 'built-ins/DataView/prototype/setInt8/index-check-before-value-conversion': [FAIL],
-
- # https://code.google.com/p/chromium/issues/detail?id=581577
- 'built-ins/RegExp/prototype/source/15.10.7.1-1': [FAIL],
- 'built-ins/RegExp/prototype/global/15.10.7.2-1': [FAIL],
- 'built-ins/RegExp/prototype/ignoreCase/15.10.7.3-1': [FAIL],
- 'built-ins/RegExp/prototype/multiline/15.10.7.4-1': [FAIL],
-
# https://bugs.chromium.org/p/v8/issues/detail?id=4727
- 'built-ins/TypedArrays/length-arg-is-undefined-throws': [FAIL],
'built-ins/TypedArrays/length-arg-is-symbol-throws': [FAIL],
- 'built-ins/TypedArrays/length-arg-is-float-throws-rangeerror': [FAIL],
- 'built-ins/TypedArrays/length-arg-is-nan-throws-rangeerror': [FAIL],
# https://bugs.chromium.org/p/v8/issues/detail?id=4784
- 'built-ins/TypedArrays/buffer-arg-defined-negative-length': [FAIL],
-
- # https://bugs.chromium.org/p/v8/issues/detail?id=4890
- 'language/statements/class/subclass/default-constructor-spread-override': [FAIL],
+ 'built-ins/TypedArray/prototype/set/typedarray-arg-negative-integer-offset-throws': [FAIL],
+ 'built-ins/TypedArray/prototype/set/array-arg-negative-integer-offset-throws': [FAIL],
# https://bugs.chromium.org/p/v8/issues/detail?id=4901
'built-ins/TypedArrays/internals/DefineOwnProperty/key-is-greater-than-last-index': [FAIL],
@@ -234,11 +168,61 @@
'built-ins/TypedArrays/internals/DefineOwnProperty/detached-buffer': [FAIL],
# Some TypedArray methods throw due to the same bug, from Get
'built-ins/TypedArray/prototype/every/callbackfn-detachbuffer': [FAIL],
+ 'built-ins/TypedArray/prototype/filter/callbackfn-detachbuffer': [FAIL],
'built-ins/TypedArray/prototype/find/predicate-may-detach-buffer': [FAIL],
'built-ins/TypedArray/prototype/findIndex/predicate-may-detach-buffer': [FAIL],
'built-ins/TypedArray/prototype/forEach/callbackfn-detachbuffer': [FAIL],
'built-ins/TypedArray/prototype/map/callbackfn-detachbuffer': [FAIL],
+ 'built-ins/TypedArray/prototype/reduce/callbackfn-detachbuffer': [FAIL],
+ 'built-ins/TypedArray/prototype/reduceRight/callbackfn-detachbuffer': [FAIL],
+ 'built-ins/TypedArray/prototype/set/array-arg-targetbuffer-detached-on-get-src-value-throws': [FAIL],
+ 'built-ins/TypedArray/prototype/set/array-arg-targetbuffer-detached-on-tointeger-offset-throws': [FAIL],
+ 'built-ins/TypedArray/prototype/set/array-arg-targetbuffer-detached-throws': [FAIL],
+ 'built-ins/TypedArray/prototype/set/typedarray-arg-srcbuffer-detached-during-tointeger-offset-throws': [FAIL],
+ 'built-ins/TypedArray/prototype/set/typedarray-arg-targetbuffer-detached-during-tointeger-offset-throws': [FAIL],
+ 'built-ins/TypedArray/prototype/slice/detached-buffer-custom-ctor-other-targettype': [FAIL],
+ 'built-ins/TypedArray/prototype/slice/detached-buffer-custom-ctor-same-targettype': [FAIL],
+ 'built-ins/TypedArray/prototype/slice/detached-buffer-get-ctor': [FAIL],
+ 'built-ins/TypedArray/prototype/slice/detached-buffer-speciesctor-get-species-custom-ctor-throws': [FAIL],
'built-ins/TypedArray/prototype/some/callbackfn-detachbuffer': [FAIL],
+ 'built-ins/TypedArray/prototype/sort/detached-buffer-comparefn': [FAIL],
+ # DataView functions should also throw on detached buffers
+ 'built-ins/DataView/prototype/getFloat32/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/getFloat32/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getFloat64/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/getFloat64/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getInt16/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/getInt16/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getInt32/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/getInt32/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getInt8/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/getInt8/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getUint16/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/getUint16/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getUint32/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/getUint32/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getUint8/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/getUint8/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setFloat32/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/setFloat32/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setFloat64/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/setFloat64/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setInt16/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/setInt16/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setInt32/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/setInt32/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setInt8/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/setInt8/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setUint16/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/setUint16/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setUint32/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/setUint32/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setUint8/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/setUint8/detached-buffer-before-outofrange-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/byteLength/detached-buffer': [FAIL],
+ 'built-ins/DataView/prototype/byteOffset/detached-buffer': [FAIL],
+ 'built-ins/DataView/detached-buffer': [FAIL],
+ 'built-ins/ArrayBuffer/prototype/byteLength/detached-buffer': [FAIL],
# https://bugs.chromium.org/p/v8/issues/detail?id=4648
'built-ins/TypedArray/prototype/copyWithin/detached-buffer': [FAIL],
@@ -256,7 +240,6 @@
'built-ins/TypedArray/prototype/lastIndexOf/detached-buffer': [FAIL],
'built-ins/TypedArray/prototype/map/detached-buffer': [FAIL],
'built-ins/TypedArray/prototype/reverse/detached-buffer': [FAIL],
- 'built-ins/TypedArray/prototype/set/detached-buffer': [FAIL],
'built-ins/TypedArray/prototype/slice/detached-buffer': [FAIL],
'built-ins/TypedArray/prototype/some/detached-buffer': [FAIL],
'built-ins/TypedArray/prototype/sort/detached-buffer': [FAIL],
@@ -265,69 +248,67 @@
'built-ins/TypedArray/prototype/toString/detached-buffer': [FAIL],
'built-ins/TypedArray/prototype/values/detached-buffer': [FAIL],
- # https://bugs.chromium.org/p/v8/issues/detail?id=4925
- 'built-ins/ThrowTypeError/forbidden-arguments': [FAIL],
- 'built-ins/ThrowTypeError/forbidden-caller': [FAIL],
-
# https://bugs.chromium.org/p/v8/issues/detail?id=4034
'built-ins/ThrowTypeError/unique-per-realm-function-proto': [FAIL],
- # https://bugs.chromium.org/p/v8/issues/detail?id=4902
- 'built-ins/TypedArray/prototype/byteLength/prop-desc': [FAIL],
- 'built-ins/TypedArray/prototype/byteOffset/prop-desc': [FAIL],
- 'built-ins/TypedArray/prototype/copyWithin/get-length-ignores-length-prop': [FAIL],
- 'built-ins/TypedArray/prototype/every/get-length-ignores-length-prop': [FAIL],
- 'built-ins/TypedArray/prototype/every/get-length-uses-internal-arraylength': [FAIL],
- 'built-ins/TypedArray/prototype/fill/get-length-ignores-length-prop': [FAIL],
- 'built-ins/TypedArray/prototype/find/get-length-ignores-length-prop': [FAIL],
- 'built-ins/TypedArray/prototype/findIndex/get-length-ignores-length-prop': [FAIL],
- 'built-ins/TypedArray/prototype/indexOf/get-length-uses-internal-arraylength': [FAIL],
- 'built-ins/TypedArray/prototype/lastIndexOf/get-length-uses-internal-arraylength': [FAIL],
- 'built-ins/TypedArray/prototype/length/prop-desc': [FAIL],
- 'built-ins/TypedArray/prototype/some/get-length-uses-internal-arraylength': [FAIL],
-
# https://bugs.chromium.org/p/v8/issues/detail?id=4231
'language/eval-code/direct/var-env-lower-lex-catch-non-strict': [FAIL],
'language/statements/try/early-catch-lex': [FAIL],
'language/statements/try/early-catch-var': [FAIL],
# https://bugs.chromium.org/p/v8/issues/detail?id=4951
- 'language/expressions/assignment/destructuring/array-elem-iter-rtrn-close': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-iter-rtrn-close-err': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-iter-rtrn-close-null': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-iter-thrw-close': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-iter-thrw-close-err': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-trlg-iter-list-rtrn-close': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-trlg-iter-list-rtrn-close-err': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-trlg-iter-list-rtrn-close-null': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-trlg-iter-list-thrw-close': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-trlg-iter-list-thrw-close-err': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-trlg-iter-rest-rtrn-close': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-trlg-iter-rest-rtrn-close-err': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-trlg-iter-rest-rtrn-close-null': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-trlg-iter-rest-thrw-close': [FAIL],
- 'language/expressions/assignment/destructuring/array-elem-trlg-iter-rest-thrw-close-err': [FAIL],
- 'language/expressions/assignment/destructuring/array-rest-iter-rtrn-close': [FAIL],
- 'language/expressions/assignment/destructuring/array-rest-iter-rtrn-close-err': [FAIL],
- 'language/expressions/assignment/destructuring/array-rest-iter-rtrn-close-null': [FAIL],
- 'language/expressions/assignment/destructuring/array-rest-iter-thrw-close': [FAIL],
- 'language/expressions/assignment/destructuring/array-rest-iter-thrw-close-err': [FAIL],
- 'language/expressions/assignment/destructuring/array-rest-lref-err': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-iter-rtrn-close': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-iter-rtrn-close-err': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-iter-rtrn-close-null': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-iter-thrw-close': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-iter-thrw-close-err': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-trlg-iter-list-rtrn-close': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-trlg-iter-list-rtrn-close-err': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-trlg-iter-list-rtrn-close-null': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-trlg-iter-list-thrw-close': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-trlg-iter-list-thrw-close-err': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-trlg-iter-rest-rtrn-close': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-trlg-iter-rest-rtrn-close-err': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-trlg-iter-rest-rtrn-close-null': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-trlg-iter-rest-thrw-close': [FAIL],
+ 'language/expressions/assignment/dstr-array-elem-trlg-iter-rest-thrw-close-err': [FAIL],
+ 'language/expressions/assignment/dstr-array-rest-iter-rtrn-close': [FAIL],
+ 'language/expressions/assignment/dstr-array-rest-iter-rtrn-close-err': [FAIL],
+ 'language/expressions/assignment/dstr-array-rest-iter-rtrn-close-null': [FAIL],
+ 'language/expressions/assignment/dstr-array-rest-iter-thrw-close': [FAIL],
+ 'language/expressions/assignment/dstr-array-rest-iter-thrw-close-err': [FAIL],
+ 'language/expressions/assignment/dstr-array-rest-lref-err': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-iter-rtrn-close': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-iter-rtrn-close-err': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-iter-rtrn-close-null': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-iter-thrw-close': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-iter-thrw-close-err': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-trlg-iter-list-rtrn-close': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-trlg-iter-list-rtrn-close-err': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-trlg-iter-list-rtrn-close-null': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-trlg-iter-list-thrw-close': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-trlg-iter-list-thrw-close-err': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-trlg-iter-rest-rtrn-close': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-trlg-iter-rest-rtrn-close-err': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-trlg-iter-rest-rtrn-close-null': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-trlg-iter-rest-thrw-close': [FAIL],
+ 'language/statements/for-of/dstr-array-elem-trlg-iter-rest-thrw-close-err': [FAIL],
+ 'language/statements/for-of/dstr-array-rest-iter-rtrn-close': [FAIL],
+ 'language/statements/for-of/dstr-array-rest-iter-rtrn-close-err': [FAIL],
+ 'language/statements/for-of/dstr-array-rest-iter-rtrn-close-null': [FAIL],
+ 'language/statements/for-of/dstr-array-rest-iter-thrw-close': [FAIL],
+ 'language/statements/for-of/dstr-array-rest-iter-thrw-close-err': [FAIL],
+ 'language/statements/for-of/dstr-array-rest-lref-err': [FAIL],
# https://bugs.chromium.org/p/v8/issues/detail?id=896
'language/literals/regexp/early-err-pattern': [FAIL],
- # https://bugs.chromium.org/p/v8/issues/detail?id=4468
+ # https://bugs.chromium.org/p/v8/issues/detail?id=4628
'language/eval-code/direct/non-definable-function-with-function': [FAIL],
'language/eval-code/direct/non-definable-function-with-variable': [FAIL],
'language/eval-code/indirect/non-definable-function-with-function': [FAIL],
'language/eval-code/indirect/non-definable-function-with-variable': [FAIL],
- # https://bugs.chromium.org/p/v8/issues/detail?id=4955
- 'language/eval-code/direct/var-env-global-lex-non-strict': [FAIL],
- 'language/eval-code/direct/var-env-lower-lex-non-strict': [FAIL],
- 'language/eval-code/indirect/var-env-global-lex-non-strict': [FAIL],
-
# https://bugs.chromium.org/p/v8/issues/detail?id=4124
'built-ins/Simd/*': [SKIP],
@@ -355,9 +336,159 @@
'built-ins/Function/prototype/toString/setter-object': [FAIL],
'built-ins/Function/prototype/toString/unicode': [FAIL],
- # https://bugs.chromium.org/p/v8/issues/detail?id=4985
- 'language/reserved-words/await-module': [SKIP],
- 'language/module-code/strict-mode': [SKIP],
+ # https://bugs.chromium.org/p/v8/issues/detail?id=1569
+ 'language/module-code/*': [SKIP],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5111
+ 'annexB/language/function-code/block-decl-func-skip-param': [FAIL],
+ 'annexB/language/function-code/if-decl-else-decl-a-func-skip-param': [FAIL],
+ 'annexB/language/function-code/if-decl-else-decl-b-func-skip-param': [FAIL],
+ 'annexB/language/function-code/if-decl-else-stmt-func-skip-param': [FAIL],
+ 'annexB/language/function-code/if-decl-no-else-func-skip-param': [FAIL],
+ 'annexB/language/function-code/if-stmt-else-decl-func-skip-param': [FAIL],
+ 'annexB/language/function-code/switch-case-func-skip-param': [FAIL],
+ 'annexB/language/function-code/switch-dflt-func-skip-param': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5112
+ 'language/statements/try/scope-catch-block-lex-open': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5012
+ 'intl402/Intl/getCanonicalLocales/*': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5113
+ 'built-ins/TypedArray/prototype/toLocaleString/calls-tolocalestring-from-each-value': [FAIL],
+ 'built-ins/TypedArray/prototype/toLocaleString/calls-tostring-from-each-value': [FAIL],
+ 'built-ins/TypedArray/prototype/toLocaleString/calls-valueof-from-each-value': [FAIL],
+ 'built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-tolocalestring': [FAIL],
+ 'built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-tostring': [FAIL],
+ 'built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-firstelement-valueof': [FAIL],
+ 'built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-tolocalestring': [FAIL],
+ 'built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-tostring': [FAIL],
+ 'built-ins/TypedArray/prototype/toLocaleString/return-abrupt-from-nextelement-valueof': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5115
+ 'language/statements/class/subclass/class-definition-null-proto-missing-return-override': [FAIL],
+ 'language/statements/class/subclass/class-definition-null-proto-this': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5116
+ 'built-ins/Object/internals/DefineOwnProperty/nan-equivalence': [PASS, FAIL],
+ 'built-ins/TypedArray/prototype/fill/fill-values-conversion-operations-consistent-nan': [PASS, FAIL],
+ 'built-ins/TypedArrays/internals/DefineOwnProperty/conversion-operation-consistent-nan': [PASS, FAIL],
+ 'built-ins/TypedArrays/internals/Set/conversion-operation-consistent-nan': [PASS, FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5070
+ 'annexB/built-ins/Object/prototype/__defineGetter__/define-non-configurable': [FAIL],
+ 'annexB/built-ins/Object/prototype/__defineGetter__/define-non-extensible': [FAIL],
+ 'annexB/built-ins/Object/prototype/__defineGetter__/this-non-obj': [FAIL],
+ 'annexB/built-ins/Object/prototype/__defineSetter__/define-non-configurable': [FAIL],
+ 'annexB/built-ins/Object/prototype/__defineSetter__/define-non-extensible': [FAIL],
+ 'annexB/built-ins/Object/prototype/__defineSetter__/this-non-obj': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupGetter__/this-non-obj': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupSetter__/this-non-obj': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5120
+ 'built-ins/DataView/negative-bytelength-throws': [FAIL],
+ 'built-ins/DataView/prototype/getFloat32/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getFloat64/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getInt16/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getInt32/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getInt8/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getUint16/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getUint32/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/getUint8/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setFloat32/no-value-arg': [FAIL],
+ 'built-ins/DataView/prototype/setFloat32/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setFloat64/no-value-arg': [FAIL],
+ 'built-ins/DataView/prototype/setFloat64/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setInt16/no-value-arg': [FAIL],
+ 'built-ins/DataView/prototype/setInt16/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setInt32/no-value-arg': [FAIL],
+ 'built-ins/DataView/prototype/setInt32/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setInt8/no-value-arg': [FAIL],
+ 'built-ins/DataView/prototype/setInt8/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setUint16/no-value-arg': [FAIL],
+ 'built-ins/DataView/prototype/setUint16/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setUint32/no-value-arg': [FAIL],
+ 'built-ins/DataView/prototype/setUint32/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/prototype/setUint8/no-value-arg': [FAIL],
+ 'built-ins/DataView/prototype/setUint8/toindex-byteoffset': [FAIL],
+ 'built-ins/DataView/toindex-byteoffset': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5121
+ 'language/expressions/assignment/destructuring/obj-prop-__proto__dup': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5124
+ 'built-ins/TypedArrays/length-arg-toindex-length': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=4973
+ 'language/literals/numeric/non-octal-decimal-integer-strict': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5130
+ 'annexB/built-ins/Object/prototype/__lookupGetter__/lookup-own-data': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupGetter__/lookup-own-get-err': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupGetter__/lookup-own-proto-err': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupGetter__/lookup-proto-data': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupGetter__/lookup-proto-get-err': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupGetter__/lookup-proto-proto-err': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupSetter__/lookup-own-data': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupSetter__/lookup-own-get-err': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupSetter__/lookup-own-proto-err': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupSetter__/lookup-proto-data': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupSetter__/lookup-proto-get-err': [FAIL],
+ 'annexB/built-ins/Object/prototype/__lookupSetter__/lookup-proto-proto-err': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5134
+ 'built-ins/Array/prototype/concat/is-concat-spreadable-is-array-proxy-revoked': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=4451
+ 'annexB/language/eval-code/direct/global-block-decl-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/direct/global-if-decl-else-decl-a-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/direct/global-if-decl-else-decl-b-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/direct/global-if-decl-else-stmt-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/direct/global-if-decl-no-else-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/direct/global-if-stmt-else-decl-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/direct/global-switch-case-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/direct/global-switch-dflt-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/indirect/global-block-decl-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/indirect/global-if-decl-else-decl-a-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/indirect/global-if-decl-else-decl-b-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/indirect/global-if-decl-else-stmt-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/indirect/global-if-decl-no-else-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/indirect/global-if-stmt-else-decl-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/indirect/global-switch-case-eval-global-exsting-global-init': [FAIL],
+ 'annexB/language/eval-code/indirect/global-switch-dflt-eval-global-exsting-global-init': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5135
+ 'annexB/language/eval-code/direct/func-block-decl-eval-func-block-scoping': [FAIL],
+ 'annexB/language/eval-code/direct/func-if-decl-else-decl-a-eval-func-block-scoping': [FAIL],
+ 'annexB/language/eval-code/direct/func-if-decl-else-decl-b-eval-func-block-scoping': [FAIL],
+ 'annexB/language/eval-code/direct/func-if-decl-else-stmt-eval-func-block-scoping': [FAIL],
+ 'annexB/language/eval-code/direct/func-if-decl-no-else-eval-func-block-scoping': [FAIL],
+ 'annexB/language/eval-code/direct/func-if-stmt-else-decl-eval-func-block-scoping': [FAIL],
+ 'annexB/language/eval-code/direct/func-switch-case-eval-func-block-scoping': [FAIL],
+ 'annexB/language/eval-code/direct/func-switch-dflt-eval-func-block-scoping': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5136
+ 'annexB/language/comments/multi-line-html-close': [FAIL],
+ 'annexB/language/comments/single-line-html-close': [FAIL],
+ 'annexB/language/comments/single-line-html-close-asi': [FAIL],
+ 'annexB/language/comments/single-line-html-open': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5137
+ 'annexB/built-ins/RegExp/prototype/compile/flags-undefined': [FAIL],
+ 'annexB/built-ins/RegExp/prototype/compile/pattern-regexp-distinct': [FAIL],
+ 'annexB/built-ins/RegExp/prototype/compile/pattern-regexp-same': [FAIL],
+ 'annexB/built-ins/RegExp/prototype/compile/pattern-undefined': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5138
+ 'annexB/built-ins/RegExp/prototype/compile/pattern-regexp-immutable-lastindex': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5139
+ 'annexB/built-ins/Date/prototype/setYear/time-clip': [FAIL],
+ 'annexB/built-ins/Date/prototype/setYear/year-number-relative': [FAIL],
+
+ # https://bugs.chromium.org/p/v8/issues/detail?id=5140
+ 'annexB/built-ins/String/prototype/substr/start-to-int-err': [FAIL],
######################## NEEDS INVESTIGATION ###########################
@@ -370,7 +501,6 @@
'intl402/Collator/10.1.2_a': [PASS, FAIL],
'intl402/Collator/10.2.3_b': [PASS, FAIL],
'intl402/Collator/prototype/10.3_a': [FAIL],
- 'intl402/DateTimeFormat/12.1.1': [FAIL],
'intl402/DateTimeFormat/12.1.2': [PASS, FAIL],
'intl402/DateTimeFormat/12.1.2.1_4': [FAIL],
'intl402/DateTimeFormat/12.2.3_b': [FAIL],
@@ -420,6 +550,15 @@
# Test262 Bug: https://bugs.ecmascript.org/show_bug.cgi?id=596
'built-ins/Array/prototype/sort/bug_596_1': [PASS, FAIL_OK],
+ # https://github.com/tc39/test262/issues/677
+ 'built-ins/RegExp/prototype/source/15.10.7.1-1': [FAIL],
+ 'built-ins/RegExp/prototype/global/15.10.7.2-1': [FAIL],
+ 'built-ins/RegExp/prototype/ignoreCase/15.10.7.3-1': [FAIL],
+ 'built-ins/RegExp/prototype/multiline/15.10.7.4-1': [FAIL],
+
+ # https://github.com/tc39/test262/issues/694
+ 'language/statements/class/subclass/builtin-objects/ArrayBuffer/regular-subclassing': [FAIL],
+
############################ SKIPPED TESTS #############################
# These tests take a looong time to run.
@@ -496,6 +635,7 @@
# https://bugs.chromium.org/p/v8/issues/detail?id=4639
# The failed allocation causes an asan/msan/tsan error
'built-ins/ArrayBuffer/allocation-limit': [SKIP],
+ 'built-ins/ArrayBuffer/length-is-too-large-throws': [SKIP],
}], # asan == True or msan == True or tsan == True
]
diff --git a/test/unittests/BUILD.gn b/test/unittests/BUILD.gn
new file mode 100644
index 0000000..b962673
--- /dev/null
+++ b/test/unittests/BUILD.gn
@@ -0,0 +1,182 @@
+# 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.
+
+# Please keep this file in sync with unittests.gyp.
+
+import("../../gni/v8.gni")
+
+v8_executable("unittests") {
+ testonly = true
+
+ sources = [
+ "base/atomic-utils-unittest.cc",
+ "base/bits-unittest.cc",
+ "base/cpu-unittest.cc",
+ "base/division-by-constant-unittest.cc",
+ "base/flags-unittest.cc",
+ "base/functional-unittest.cc",
+ "base/ieee754-unittest.cc",
+ "base/iterator-unittest.cc",
+ "base/logging-unittest.cc",
+ "base/platform/condition-variable-unittest.cc",
+ "base/platform/mutex-unittest.cc",
+ "base/platform/platform-unittest.cc",
+ "base/platform/semaphore-unittest.cc",
+ "base/platform/time-unittest.cc",
+ "base/sys-info-unittest.cc",
+ "base/utils/random-number-generator-unittest.cc",
+ "cancelable-tasks-unittest.cc",
+ "char-predicates-unittest.cc",
+ "compiler/branch-elimination-unittest.cc",
+ "compiler/checkpoint-elimination-unittest.cc",
+ "compiler/common-operator-reducer-unittest.cc",
+ "compiler/common-operator-unittest.cc",
+ "compiler/compiler-test-utils.h",
+ "compiler/control-equivalence-unittest.cc",
+ "compiler/control-flow-optimizer-unittest.cc",
+ "compiler/dead-code-elimination-unittest.cc",
+ "compiler/diamond-unittest.cc",
+ "compiler/effect-control-linearizer-unittest.cc",
+ "compiler/escape-analysis-unittest.cc",
+ "compiler/graph-reducer-unittest.cc",
+ "compiler/graph-reducer-unittest.h",
+ "compiler/graph-trimmer-unittest.cc",
+ "compiler/graph-unittest.cc",
+ "compiler/graph-unittest.h",
+ "compiler/instruction-selector-unittest.cc",
+ "compiler/instruction-selector-unittest.h",
+ "compiler/instruction-sequence-unittest.cc",
+ "compiler/instruction-sequence-unittest.h",
+ "compiler/int64-lowering-unittest.cc",
+ "compiler/js-builtin-reducer-unittest.cc",
+ "compiler/js-create-lowering-unittest.cc",
+ "compiler/js-intrinsic-lowering-unittest.cc",
+ "compiler/js-operator-unittest.cc",
+ "compiler/js-typed-lowering-unittest.cc",
+ "compiler/linkage-tail-call-unittest.cc",
+ "compiler/live-range-unittest.cc",
+ "compiler/liveness-analyzer-unittest.cc",
+ "compiler/load-elimination-unittest.cc",
+ "compiler/loop-peeling-unittest.cc",
+ "compiler/machine-operator-reducer-unittest.cc",
+ "compiler/machine-operator-unittest.cc",
+ "compiler/move-optimizer-unittest.cc",
+ "compiler/node-cache-unittest.cc",
+ "compiler/node-matchers-unittest.cc",
+ "compiler/node-properties-unittest.cc",
+ "compiler/node-test-utils.cc",
+ "compiler/node-test-utils.h",
+ "compiler/node-unittest.cc",
+ "compiler/opcodes-unittest.cc",
+ "compiler/register-allocator-unittest.cc",
+ "compiler/schedule-unittest.cc",
+ "compiler/scheduler-rpo-unittest.cc",
+ "compiler/scheduler-unittest.cc",
+ "compiler/simplified-operator-reducer-unittest.cc",
+ "compiler/simplified-operator-unittest.cc",
+ "compiler/state-values-utils-unittest.cc",
+ "compiler/tail-call-optimization-unittest.cc",
+ "compiler/typer-unittest.cc",
+ "compiler/value-numbering-reducer-unittest.cc",
+ "compiler/zone-pool-unittest.cc",
+ "counters-unittest.cc",
+ "heap/bitmap-unittest.cc",
+ "heap/gc-idle-time-handler-unittest.cc",
+ "heap/gc-tracer-unittest.cc",
+ "heap/heap-unittest.cc",
+ "heap/memory-reducer-unittest.cc",
+ "heap/scavenge-job-unittest.cc",
+ "heap/slot-set-unittest.cc",
+ "interpreter/bytecode-array-builder-unittest.cc",
+ "interpreter/bytecode-array-iterator-unittest.cc",
+ "interpreter/bytecode-array-writer-unittest.cc",
+ "interpreter/bytecode-dead-code-optimizer-unittest.cc",
+ "interpreter/bytecode-peephole-optimizer-unittest.cc",
+ "interpreter/bytecode-pipeline-unittest.cc",
+ "interpreter/bytecode-register-allocator-unittest.cc",
+ "interpreter/bytecode-register-optimizer-unittest.cc",
+ "interpreter/bytecodes-unittest.cc",
+ "interpreter/constant-array-builder-unittest.cc",
+ "interpreter/interpreter-assembler-unittest.cc",
+ "interpreter/interpreter-assembler-unittest.h",
+ "interpreter/source-position-table-unittest.cc",
+ "libplatform/default-platform-unittest.cc",
+ "libplatform/task-queue-unittest.cc",
+ "libplatform/worker-thread-unittest.cc",
+ "locked-queue-unittest.cc",
+ "register-configuration-unittest.cc",
+ "run-all-unittests.cc",
+ "test-utils.cc",
+ "test-utils.h",
+ "wasm/asm-types-unittest.cc",
+ "wasm/ast-decoder-unittest.cc",
+ "wasm/control-transfer-unittest.cc",
+ "wasm/decoder-unittest.cc",
+ "wasm/encoder-unittest.cc",
+ "wasm/leb-helper-unittest.cc",
+ "wasm/loop-assignment-analysis-unittest.cc",
+ "wasm/module-decoder-unittest.cc",
+ "wasm/switch-logic-unittest.cc",
+ "wasm/wasm-macro-gen-unittest.cc",
+ ]
+
+ if (v8_target_cpu == "arm") {
+ sources += [ "compiler/arm/instruction-selector-arm-unittest.cc" ]
+ } else if (v8_target_cpu == "arm64") {
+ sources += [ "compiler/arm64/instruction-selector-arm64-unittest.cc" ]
+ } else if (v8_target_cpu == "x86") {
+ sources += [ "compiler/ia32/instruction-selector-ia32-unittest.cc" ]
+ } else if (v8_target_cpu == "mips" || v8_target_cpu == "mipsel") {
+ sources += [ "compiler/mips/instruction-selector-mips-unittest.cc" ]
+ } else if (v8_target_cpu == "mips64" || v8_target_cpu == "mips64el") {
+ sources += [ "compiler/mips64/instruction-selector-mips64-unittest.cc" ]
+ } else if (v8_target_cpu == "x64") {
+ sources += [ "compiler/x64/instruction-selector-x64-unittest.cc" ]
+ } else if (v8_target_cpu == "ppc" || v8_target_cpu == "ppc64") {
+ sources += [ "compiler/ppc/instruction-selector-ppc-unittest.cc" ]
+ } else if (v8_target_cpu == "s390" || v8_target_cpu == "s390x") {
+ sources += [ "compiler/s390/instruction-selector-s390-unittest.cc" ]
+ }
+
+ configs = [
+ "../..:external_config",
+ "../..:internal_config_base",
+ ]
+
+ # TODO(machenbach): Translate from gyp.
+ #['OS=="aix"', {
+ # 'ldflags': [ '-Wl,-bbigtoc' ],
+ #}],
+
+ deps = [
+ "../..:v8_libplatform",
+ "//build/config/sanitizers:deps",
+ "//build/win:default_exe_manifest",
+ "//testing/gmock",
+ "//testing/gtest",
+ ]
+
+ if (is_component_build) {
+ # compiler-unittests can't be built against a shared library, so we
+ # need to depend on the underlying static target in that case.
+ deps += [ "../..:v8_maybe_snapshot" ]
+ } else {
+ deps += [ "../..:v8" ]
+ }
+
+ if (is_win) {
+ # This warning is benignly triggered by the U16 and U32 macros in
+ # bytecode-utils.h.
+ # C4309: 'static_cast': truncation of constant value
+ cflags = [ "/wd4309" ]
+
+ # Suppress warnings about importing locally defined symbols.
+ if (is_component_build) {
+ ldflags = [
+ "/ignore:4049",
+ "/ignore:4217",
+ ]
+ }
+ }
+}
diff --git a/test/unittests/base/ieee754-unittest.cc b/test/unittests/base/ieee754-unittest.cc
new file mode 100644
index 0000000..8c71b57
--- /dev/null
+++ b/test/unittests/base/ieee754-unittest.cc
@@ -0,0 +1,323 @@
+// 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 <limits>
+
+#include "src/base/ieee754.h"
+#include "src/base/macros.h"
+#include "testing/gmock-support.h"
+#include "testing/gtest-support.h"
+
+using testing::BitEq;
+using testing::IsNaN;
+
+namespace v8 {
+namespace base {
+namespace ieee754 {
+
+namespace {
+
+double const kE = 2.718281828459045;
+double const kPI = 3.141592653589793;
+double const kTwo120 = 1.329227995784916e+36;
+
+} // namespace
+
+TEST(Ieee754, Atan) {
+ EXPECT_THAT(atan(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(atan(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_THAT(atan(-0.0), BitEq(-0.0));
+ EXPECT_THAT(atan(0.0), BitEq(0.0));
+ EXPECT_DOUBLE_EQ(1.5707963267948966,
+ atan(std::numeric_limits<double>::infinity()));
+ EXPECT_DOUBLE_EQ(-1.5707963267948966,
+ atan(-std::numeric_limits<double>::infinity()));
+}
+
+TEST(Ieee754, Atan2) {
+ EXPECT_THAT(atan2(std::numeric_limits<double>::quiet_NaN(),
+ std::numeric_limits<double>::quiet_NaN()),
+ IsNaN());
+ EXPECT_THAT(atan2(std::numeric_limits<double>::quiet_NaN(),
+ std::numeric_limits<double>::signaling_NaN()),
+ IsNaN());
+ EXPECT_THAT(atan2(std::numeric_limits<double>::signaling_NaN(),
+ std::numeric_limits<double>::quiet_NaN()),
+ IsNaN());
+ EXPECT_THAT(atan2(std::numeric_limits<double>::signaling_NaN(),
+ std::numeric_limits<double>::signaling_NaN()),
+ IsNaN());
+ EXPECT_DOUBLE_EQ(0.7853981633974483,
+ atan2(std::numeric_limits<double>::infinity(),
+ std::numeric_limits<double>::infinity()));
+ EXPECT_DOUBLE_EQ(2.356194490192345,
+ atan2(std::numeric_limits<double>::infinity(),
+ -std::numeric_limits<double>::infinity()));
+ EXPECT_DOUBLE_EQ(-0.7853981633974483,
+ atan2(-std::numeric_limits<double>::infinity(),
+ std::numeric_limits<double>::infinity()));
+ EXPECT_DOUBLE_EQ(-2.356194490192345,
+ atan2(-std::numeric_limits<double>::infinity(),
+ -std::numeric_limits<double>::infinity()));
+}
+
+TEST(Ieee754, Atanh) {
+ EXPECT_THAT(atanh(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(atanh(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_THAT(atanh(std::numeric_limits<double>::infinity()), IsNaN());
+ EXPECT_EQ(std::numeric_limits<double>::infinity(), atanh(1));
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(), atanh(-1));
+ EXPECT_DOUBLE_EQ(0.54930614433405478, atanh(0.5));
+}
+
+TEST(Ieee754, Cos) {
+ // Test values mentioned in the EcmaScript spec.
+ EXPECT_THAT(cos(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(cos(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_THAT(cos(std::numeric_limits<double>::infinity()), IsNaN());
+ EXPECT_THAT(cos(-std::numeric_limits<double>::infinity()), IsNaN());
+
+ // Tests for cos for |x| < pi/4
+ EXPECT_EQ(1.0, 1 / cos(-0.0));
+ EXPECT_EQ(1.0, 1 / cos(0.0));
+ // cos(x) = 1 for |x| < 2^-27
+ EXPECT_EQ(1, cos(2.3283064365386963e-10));
+ EXPECT_EQ(1, cos(-2.3283064365386963e-10));
+ // Test KERNELCOS for |x| < 0.3.
+ // cos(pi/20) = sqrt(sqrt(2)*sqrt(sqrt(5)+5)+4)/2^(3/2)
+ EXPECT_EQ(0.9876883405951378, cos(0.15707963267948966));
+ // Test KERNELCOS for x ~= 0.78125
+ EXPECT_EQ(0.7100335477927638, cos(0.7812504768371582));
+ EXPECT_EQ(0.7100338835660797, cos(0.78125));
+ // Test KERNELCOS for |x| > 0.3.
+ // cos(pi/8) = sqrt(sqrt(2)+1)/2^(3/4)
+ EXPECT_EQ(0.9238795325112867, cos(0.39269908169872414));
+ // Test KERNELTAN for |x| < 0.67434.
+ EXPECT_EQ(0.9238795325112867, cos(-0.39269908169872414));
+
+ // Tests for cos.
+ EXPECT_EQ(1, cos(3.725290298461914e-9));
+ // Cover different code paths in KERNELCOS.
+ EXPECT_EQ(0.9689124217106447, cos(0.25));
+ EXPECT_EQ(0.8775825618903728, cos(0.5));
+ EXPECT_EQ(0.7073882691671998, cos(0.785));
+ // Test that cos(Math.PI/2) != 0 since Math.PI is not exact.
+ EXPECT_EQ(6.123233995736766e-17, cos(1.5707963267948966));
+ // Test cos for various phases.
+ EXPECT_EQ(0.7071067811865474, cos(7.0 / 4 * kPI));
+ EXPECT_EQ(0.7071067811865477, cos(9.0 / 4 * kPI));
+ EXPECT_EQ(-0.7071067811865467, cos(11.0 / 4 * kPI));
+ EXPECT_EQ(-0.7071067811865471, cos(13.0 / 4 * kPI));
+ EXPECT_EQ(0.9367521275331447, cos(1000000.0));
+ EXPECT_EQ(-3.435757038074824e-12, cos(1048575.0 / 2 * kPI));
+
+ // Test Hayne-Panek reduction.
+ EXPECT_EQ(-0.9258790228548379e0, cos(kTwo120));
+ EXPECT_EQ(-0.9258790228548379e0, cos(-kTwo120));
+}
+
+TEST(Ieee754, Exp) {
+ EXPECT_THAT(exp(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(exp(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_EQ(0.0, exp(-std::numeric_limits<double>::infinity()));
+ EXPECT_EQ(0.0, exp(-1000));
+ EXPECT_EQ(0.0, exp(-745.1332191019412));
+ EXPECT_EQ(2.2250738585072626e-308, exp(-708.39641853226408));
+ EXPECT_EQ(3.307553003638408e-308, exp(-708.0));
+ EXPECT_EQ(4.9406564584124654e-324, exp(-7.45133219101941108420e+02));
+ EXPECT_EQ(0.36787944117144233, exp(-1.0));
+ EXPECT_EQ(1.0, exp(-0.0));
+ EXPECT_EQ(1.0, exp(0.0));
+ EXPECT_EQ(1.0, exp(2.2250738585072014e-308));
+
+ // Test that exp(x) is monotonic near 1.
+ EXPECT_GE(exp(1.0), exp(0.9999999999999999));
+ EXPECT_LE(exp(1.0), exp(1.0000000000000002));
+
+ // Test that we produce the correctly rounded result for 1.
+ EXPECT_EQ(kE, exp(1.0));
+
+ EXPECT_EQ(7.38905609893065e0, exp(2.0));
+ EXPECT_EQ(1.7976931348622732e308, exp(7.09782712893383973096e+02));
+ EXPECT_EQ(2.6881171418161356e+43, exp(100.0));
+ EXPECT_EQ(8.218407461554972e+307, exp(709.0));
+ EXPECT_EQ(1.7968190737295725e308, exp(709.7822265625e0));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(), exp(709.7827128933841e0));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(), exp(710.0));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(), exp(1000.0));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(),
+ exp(std::numeric_limits<double>::infinity()));
+}
+
+TEST(Ieee754, Expm1) {
+ EXPECT_THAT(expm1(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(expm1(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_EQ(-1.0, expm1(-std::numeric_limits<double>::infinity()));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(),
+ expm1(std::numeric_limits<double>::infinity()));
+ EXPECT_EQ(0.0, expm1(-0.0));
+ EXPECT_EQ(0.0, expm1(0.0));
+ EXPECT_EQ(1.718281828459045, expm1(1.0));
+ EXPECT_EQ(2.6881171418161356e+43, expm1(100.0));
+ EXPECT_EQ(8.218407461554972e+307, expm1(709.0));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(), expm1(710.0));
+}
+
+TEST(Ieee754, Log) {
+ EXPECT_THAT(log(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(log(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_THAT(log(-std::numeric_limits<double>::infinity()), IsNaN());
+ EXPECT_THAT(log(-1.0), IsNaN());
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(), log(-0.0));
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(), log(0.0));
+ EXPECT_EQ(0.0, log(1.0));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(),
+ log(std::numeric_limits<double>::infinity()));
+
+ // Test that log(E) produces the correctly rounded result.
+ EXPECT_EQ(1.0, log(kE));
+}
+
+TEST(Ieee754, Log1p) {
+ EXPECT_THAT(log1p(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(log1p(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_THAT(log1p(-std::numeric_limits<double>::infinity()), IsNaN());
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(), log1p(-1.0));
+ EXPECT_EQ(0.0, log1p(0.0));
+ EXPECT_EQ(-0.0, log1p(-0.0));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(),
+ log1p(std::numeric_limits<double>::infinity()));
+ EXPECT_EQ(6.9756137364252422e-03, log1p(0.007));
+ EXPECT_EQ(709.782712893384, log1p(1.7976931348623157e308));
+ EXPECT_EQ(2.7755575615628914e-17, log1p(2.7755575615628914e-17));
+ EXPECT_EQ(9.313225741817976e-10, log1p(9.313225746154785e-10));
+ EXPECT_EQ(-0.2876820724517809, log1p(-0.25));
+ EXPECT_EQ(0.22314355131420976, log1p(0.25));
+ EXPECT_EQ(2.3978952727983707, log1p(10));
+ EXPECT_EQ(36.841361487904734, log1p(10e15));
+ EXPECT_EQ(37.08337388996168, log1p(12738099905822720));
+ EXPECT_EQ(37.08336444902049, log1p(12737979646738432));
+ EXPECT_EQ(1.3862943611198906, log1p(3));
+ EXPECT_EQ(1.3862945995384413, log1p(3 + 9.5367431640625e-7));
+ EXPECT_EQ(0.5596157879354227, log1p(0.75));
+ EXPECT_EQ(0.8109302162163288, log1p(1.25));
+}
+
+TEST(Ieee754, Log2) {
+ EXPECT_THAT(log2(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(log2(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_THAT(log2(-std::numeric_limits<double>::infinity()), IsNaN());
+ EXPECT_THAT(log2(-1.0), IsNaN());
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(), log2(0.0));
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(), log2(-0.0));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(),
+ log2(std::numeric_limits<double>::infinity()));
+}
+
+TEST(Ieee754, Log10) {
+ EXPECT_THAT(log10(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(log10(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_THAT(log10(-std::numeric_limits<double>::infinity()), IsNaN());
+ EXPECT_THAT(log10(-1.0), IsNaN());
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(), log10(0.0));
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(), log10(-0.0));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(),
+ log10(std::numeric_limits<double>::infinity()));
+ EXPECT_EQ(3.0, log10(1000.0));
+ EXPECT_EQ(14.0, log10(100000000000000)); // log10(10 ^ 14)
+ EXPECT_EQ(3.7389561269540406, log10(5482.2158));
+ EXPECT_EQ(14.661551142893833, log10(458723662312872.125782332587));
+ EXPECT_EQ(-0.9083828622192334, log10(0.12348583358871));
+ EXPECT_EQ(5.0, log10(100000.0));
+}
+
+TEST(Ieee754, Cbrt) {
+ EXPECT_THAT(cbrt(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(cbrt(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_EQ(std::numeric_limits<double>::infinity(),
+ cbrt(std::numeric_limits<double>::infinity()));
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(),
+ cbrt(-std::numeric_limits<double>::infinity()));
+ EXPECT_EQ(1.4422495703074083, cbrt(3));
+ EXPECT_EQ(100, cbrt(100 * 100 * 100));
+ EXPECT_EQ(46.415888336127786, cbrt(100000));
+}
+
+TEST(Ieee754, Sin) {
+ // Test values mentioned in the EcmaScript spec.
+ EXPECT_THAT(sin(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(sin(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_THAT(sin(std::numeric_limits<double>::infinity()), IsNaN());
+ EXPECT_THAT(sin(-std::numeric_limits<double>::infinity()), IsNaN());
+
+ // Tests for sin for |x| < pi/4
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(), 1 / sin(-0.0));
+ EXPECT_EQ(std::numeric_limits<double>::infinity(), 1 / sin(0.0));
+ // sin(x) = x for x < 2^-27
+ EXPECT_EQ(2.3283064365386963e-10, sin(2.3283064365386963e-10));
+ EXPECT_EQ(-2.3283064365386963e-10, sin(-2.3283064365386963e-10));
+ // sin(pi/8) = sqrt(sqrt(2)-1)/2^(3/4)
+ EXPECT_EQ(0.3826834323650898, sin(0.39269908169872414));
+ EXPECT_EQ(-0.3826834323650898, sin(-0.39269908169872414));
+
+ // Tests for sin.
+ EXPECT_EQ(0.479425538604203, sin(0.5));
+ EXPECT_EQ(-0.479425538604203, sin(-0.5));
+ EXPECT_EQ(1, sin(kPI / 2.0));
+ EXPECT_EQ(-1, sin(-kPI / 2.0));
+ // Test that sin(Math.PI) != 0 since Math.PI is not exact.
+ EXPECT_EQ(1.2246467991473532e-16, sin(kPI));
+ EXPECT_EQ(-7.047032979958965e-14, sin(2200.0 * kPI));
+ // Test sin for various phases.
+ EXPECT_EQ(-0.7071067811865477, sin(7.0 / 4.0 * kPI));
+ EXPECT_EQ(0.7071067811865474, sin(9.0 / 4.0 * kPI));
+ EXPECT_EQ(0.7071067811865483, sin(11.0 / 4.0 * kPI));
+ EXPECT_EQ(-0.7071067811865479, sin(13.0 / 4.0 * kPI));
+ EXPECT_EQ(-3.2103381051568376e-11, sin(1048576.0 / 4 * kPI));
+
+ // Test Hayne-Panek reduction.
+ EXPECT_EQ(0.377820109360752e0, sin(kTwo120));
+ EXPECT_EQ(-0.377820109360752e0, sin(-kTwo120));
+}
+
+TEST(Ieee754, Tan) {
+ // Test values mentioned in the EcmaScript spec.
+ EXPECT_THAT(tan(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+ EXPECT_THAT(tan(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+ EXPECT_THAT(tan(std::numeric_limits<double>::infinity()), IsNaN());
+ EXPECT_THAT(tan(-std::numeric_limits<double>::infinity()), IsNaN());
+
+ // Tests for tan for |x| < pi/4
+ EXPECT_EQ(std::numeric_limits<double>::infinity(), 1 / tan(0.0));
+ EXPECT_EQ(-std::numeric_limits<double>::infinity(), 1 / tan(-0.0));
+ // tan(x) = x for |x| < 2^-28
+ EXPECT_EQ(2.3283064365386963e-10, tan(2.3283064365386963e-10));
+ EXPECT_EQ(-2.3283064365386963e-10, tan(-2.3283064365386963e-10));
+ // Test KERNELTAN for |x| > 0.67434.
+ EXPECT_EQ(0.8211418015898941, tan(11.0 / 16.0));
+ EXPECT_EQ(-0.8211418015898941, tan(-11.0 / 16.0));
+ EXPECT_EQ(0.41421356237309503, tan(0.39269908169872414));
+ // crbug/427468
+ EXPECT_EQ(0.7993357819992383, tan(0.6743358));
+
+ // Tests for tan.
+ EXPECT_EQ(3.725290298461914e-9, tan(3.725290298461914e-9));
+ // Test that tan(PI/2) != Infinity since PI is not exact.
+ EXPECT_EQ(1.633123935319537e16, tan(kPI / 2));
+ // Cover different code paths in KERNELTAN (tangent and cotangent)
+ EXPECT_EQ(0.5463024898437905, tan(0.5));
+ EXPECT_EQ(2.0000000000000027, tan(1.107148717794091));
+ EXPECT_EQ(-1.0000000000000004, tan(7.0 / 4.0 * kPI));
+ EXPECT_EQ(0.9999999999999994, tan(9.0 / 4.0 * kPI));
+ EXPECT_EQ(-6.420676210313675e-11, tan(1048576.0 / 2.0 * kPI));
+ EXPECT_EQ(2.910566692924059e11, tan(1048575.0 / 2.0 * kPI));
+
+ // Test Hayne-Panek reduction.
+ EXPECT_EQ(-0.40806638884180424e0, tan(kTwo120));
+ EXPECT_EQ(0.40806638884180424e0, tan(-kTwo120));
+}
+
+} // namespace ieee754
+} // namespace base
+} // namespace v8
diff --git a/test/unittests/base/platform/time-unittest.cc b/test/unittests/base/platform/time-unittest.cc
index 784fbf8..9aa609f 100644
--- a/test/unittests/base/platform/time-unittest.cc
+++ b/test/unittests/base/platform/time-unittest.cc
@@ -15,6 +15,8 @@
#include "src/base/win32-headers.h"
#endif
+#include <vector>
+
#include "src/base/platform/elapsed-timer.h"
#include "src/base/platform/platform.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -185,7 +187,7 @@
// Disable on windows until it is implemented.
-#if V8_OS_ANDROID || V8_OS_WIN
+#if V8_OS_ANDROID
#define MAYBE_ThreadNow DISABLED_ThreadNow
#else
#define MAYBE_ThreadNow ThreadNow
@@ -210,5 +212,50 @@
}
}
+
+#if V8_OS_WIN
+TEST(TimeTicks, TimerPerformance) {
+ // Verify that various timer mechanisms can always complete quickly.
+ // Note: This is a somewhat arbitrary test.
+ const int kLoops = 10000;
+
+ typedef TimeTicks (*TestFunc)();
+ struct TestCase {
+ TestFunc func;
+ const char *description;
+ };
+ // Cheating a bit here: assumes sizeof(TimeTicks) == sizeof(Time)
+ // in order to create a single test case list.
+ static_assert(sizeof(TimeTicks) == sizeof(Time),
+ "TimeTicks and Time must be the same size");
+ std::vector<TestCase> cases;
+ cases.push_back({reinterpret_cast<TestFunc>(&Time::Now), "Time::Now"});
+ cases.push_back({&TimeTicks::Now, "TimeTicks::Now"});
+
+ if (ThreadTicks::IsSupported()) {
+ ThreadTicks::WaitUntilInitialized();
+ cases.push_back(
+ {reinterpret_cast<TestFunc>(&ThreadTicks::Now), "ThreadTicks::Now"});
+ }
+
+ for (const auto& test_case : cases) {
+ TimeTicks start = TimeTicks::Now();
+ for (int index = 0; index < kLoops; index++)
+ test_case.func();
+ TimeTicks stop = TimeTicks::Now();
+ // Turning off the check for acceptible delays. Without this check,
+ // the test really doesn't do much other than measure. But the
+ // measurements are still useful for testing timers on various platforms.
+ // The reason to remove the check is because the tests run on many
+ // buildbots, some of which are VMs. These machines can run horribly
+ // slow, and there is really no value for checking against a max timer.
+ // const int kMaxTime = 35; // Maximum acceptible milliseconds for test.
+ // EXPECT_LT((stop - start).InMilliseconds(), kMaxTime);
+ printf("%s: %1.2fus per call\n", test_case.description,
+ (stop - start).InMillisecondsF() * 1000 / kLoops);
+ }
+}
+#endif // V8_OS_WIN
+
} // namespace base
} // namespace v8
diff --git a/test/unittests/compiler/arm/instruction-selector-arm-unittest.cc b/test/unittests/compiler/arm/instruction-selector-arm-unittest.cc
index b088d8e..fa03039 100644
--- a/test/unittests/compiler/arm/instruction-selector-arm-unittest.cc
+++ b/test/unittests/compiler/arm/instruction-selector-arm-unittest.cc
@@ -1392,8 +1392,8 @@
EXPECT_EQ(memacc.str_opcode, s[0]->arch_opcode());
EXPECT_EQ(kMode_Offset_RI, s[0]->addressing_mode());
ASSERT_EQ(3U, s[0]->InputCount());
- ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
- EXPECT_EQ(index, s.ToInt32(s[0]->InputAt(1)));
+ ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(2)->kind());
+ EXPECT_EQ(index, s.ToInt32(s[0]->InputAt(2)));
EXPECT_EQ(0U, s[0]->OutputCount());
}
}
@@ -1403,6 +1403,39 @@
InstructionSelectorMemoryAccessTest,
::testing::ValuesIn(kMemoryAccesses));
+TEST_F(InstructionSelectorMemoryAccessTest, LoadWithShiftedIndex) {
+ TRACED_FORRANGE(int, immediate_shift, 1, 31) {
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Pointer(),
+ MachineType::Int32());
+ Node* const index =
+ m.Word32Shl(m.Parameter(1), m.Int32Constant(immediate_shift));
+ m.Return(m.Load(MachineType::Int32(), m.Parameter(0), index));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmLdr, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_Operand2_R_LSL_I, s[0]->addressing_mode());
+ EXPECT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ }
+}
+
+TEST_F(InstructionSelectorMemoryAccessTest, StoreWithShiftedIndex) {
+ TRACED_FORRANGE(int, immediate_shift, 1, 31) {
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Pointer(),
+ MachineType::Int32(), MachineType::Int32());
+ Node* const index =
+ m.Word32Shl(m.Parameter(1), m.Int32Constant(immediate_shift));
+ m.Store(MachineRepresentation::kWord32, m.Parameter(0), index,
+ m.Parameter(2), kNoWriteBarrier);
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmStr, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_Operand2_R_LSL_I, s[0]->addressing_mode());
+ EXPECT_EQ(4U, s[0]->InputCount());
+ EXPECT_EQ(0U, s[0]->OutputCount());
+ }
+}
// -----------------------------------------------------------------------------
// Conversions.
@@ -2228,7 +2261,7 @@
MachineType::Int32(), MachineType::Int32());
m.Return(
m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
- Stream s = m.Build(MLS);
+ Stream s = m.Build(ARMv7);
ASSERT_EQ(1U, s.size());
EXPECT_EQ(kArmMls, s[0]->arch_opcode());
EXPECT_EQ(1U, s[0]->OutputCount());
@@ -2324,7 +2357,7 @@
StreamBuilder m(this, MachineType::Int32(), MachineType::Int32(),
MachineType::Int32());
m.Return(m.Int32Mod(m.Parameter(0), m.Parameter(1)));
- Stream s = m.Build(MLS, SUDIV);
+ Stream s = m.Build(ARMv7, SUDIV);
ASSERT_EQ(2U, s.size());
EXPECT_EQ(kArmSdiv, s[0]->arch_opcode());
ASSERT_EQ(1U, s[0]->OutputCount());
@@ -2530,7 +2563,7 @@
StreamBuilder m(this, MachineType::Int32(), MachineType::Int32(),
MachineType::Int32());
m.Return(m.Uint32Mod(m.Parameter(0), m.Parameter(1)));
- Stream s = m.Build(MLS, SUDIV);
+ Stream s = m.Build(ARMv7, SUDIV);
ASSERT_EQ(2U, s.size());
EXPECT_EQ(kArmUdiv, s[0]->arch_opcode());
ASSERT_EQ(1U, s[0]->OutputCount());
@@ -3026,6 +3059,36 @@
EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
}
+TEST_F(InstructionSelectorTest, Float32Neg) {
+ StreamBuilder m(this, MachineType::Float32(), MachineType::Float32());
+ Node* const p0 = m.Parameter(0);
+ // Don't use m.Float32Neg() as that generates an explicit sub.
+ Node* const n = m.AddNode(m.machine()->Float32Neg().op(), m.Parameter(0));
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmVnegF32, s[0]->arch_opcode());
+ ASSERT_EQ(1U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+}
+
+TEST_F(InstructionSelectorTest, Float64Neg) {
+ StreamBuilder m(this, MachineType::Float64(), MachineType::Float64());
+ Node* const p0 = m.Parameter(0);
+ // Don't use m.Float64Neg() as that generates an explicit sub.
+ Node* const n = m.AddNode(m.machine()->Float64Neg().op(), m.Parameter(0));
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmVnegF64, s[0]->arch_opcode());
+ ASSERT_EQ(1U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
diff --git a/test/unittests/compiler/arm64/instruction-selector-arm64-unittest.cc b/test/unittests/compiler/arm64/instruction-selector-arm64-unittest.cc
index 1c638b2..5fc210b 100644
--- a/test/unittests/compiler/arm64/instruction-selector-arm64-unittest.cc
+++ b/test/unittests/compiler/arm64/instruction-selector-arm64-unittest.cc
@@ -184,8 +184,11 @@
{&RawMachineAssembler::Int32AddWithOverflow, "Int32AddWithOverflow",
kArm64Add32, MachineType::Int32()},
{&RawMachineAssembler::Int32SubWithOverflow, "Int32SubWithOverflow",
- kArm64Sub32, MachineType::Int32()}};
-
+ kArm64Sub32, MachineType::Int32()},
+ {&RawMachineAssembler::Int64AddWithOverflow, "Int64AddWithOverflow",
+ kArm64Add, MachineType::Int64()},
+ {&RawMachineAssembler::Int64SubWithOverflow, "Int64SubWithOverflow",
+ kArm64Sub, MachineType::Int64()}};
// ARM64 shift instructions.
const Shift kShiftInstructions[] = {
@@ -1178,7 +1181,6 @@
}
}
-
TEST_F(InstructionSelectorTest, Word32AndBranchWithOneBitMaskOnLeft) {
TRACED_FORRANGE(int, bit, 0, 31) {
uint32_t mask = 1 << bit;
@@ -1261,6 +1263,91 @@
}
}
+TEST_F(InstructionSelectorTest, Word32EqualZeroAndBranchWithOneBitMask) {
+ TRACED_FORRANGE(int, bit, 0, 31) {
+ uint32_t mask = 1 << bit;
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Int32());
+ RawMachineLabel a, b;
+ m.Branch(m.Word32Equal(m.Word32And(m.Int32Constant(mask), m.Parameter(0)),
+ m.Int32Constant(0)),
+ &a, &b);
+ m.Bind(&a);
+ m.Return(m.Int32Constant(1));
+ m.Bind(&b);
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64TestAndBranch32, s[0]->arch_opcode());
+ EXPECT_EQ(kEqual, s[0]->flags_condition());
+ EXPECT_EQ(4U, s[0]->InputCount());
+ EXPECT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ EXPECT_EQ(bit, s.ToInt32(s[0]->InputAt(1)));
+ }
+
+ TRACED_FORRANGE(int, bit, 0, 31) {
+ uint32_t mask = 1 << bit;
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Int32());
+ RawMachineLabel a, b;
+ m.Branch(
+ m.Word32NotEqual(m.Word32And(m.Int32Constant(mask), m.Parameter(0)),
+ m.Int32Constant(0)),
+ &a, &b);
+ m.Bind(&a);
+ m.Return(m.Int32Constant(1));
+ m.Bind(&b);
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64TestAndBranch32, s[0]->arch_opcode());
+ EXPECT_EQ(kNotEqual, s[0]->flags_condition());
+ EXPECT_EQ(4U, s[0]->InputCount());
+ EXPECT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ EXPECT_EQ(bit, s.ToInt32(s[0]->InputAt(1)));
+ }
+}
+
+TEST_F(InstructionSelectorTest, Word64EqualZeroAndBranchWithOneBitMask) {
+ TRACED_FORRANGE(int, bit, 0, 63) {
+ uint64_t mask = V8_UINT64_C(1) << bit;
+ StreamBuilder m(this, MachineType::Int64(), MachineType::Int64());
+ RawMachineLabel a, b;
+ m.Branch(m.Word64Equal(m.Word64And(m.Int64Constant(mask), m.Parameter(0)),
+ m.Int64Constant(0)),
+ &a, &b);
+ m.Bind(&a);
+ m.Return(m.Int64Constant(1));
+ m.Bind(&b);
+ m.Return(m.Int64Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64TestAndBranch, s[0]->arch_opcode());
+ EXPECT_EQ(kEqual, s[0]->flags_condition());
+ EXPECT_EQ(4U, s[0]->InputCount());
+ EXPECT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ EXPECT_EQ(bit, s.ToInt64(s[0]->InputAt(1)));
+ }
+
+ TRACED_FORRANGE(int, bit, 0, 63) {
+ uint64_t mask = V8_UINT64_C(1) << bit;
+ StreamBuilder m(this, MachineType::Int64(), MachineType::Int64());
+ RawMachineLabel a, b;
+ m.Branch(
+ m.Word64NotEqual(m.Word64And(m.Int64Constant(mask), m.Parameter(0)),
+ m.Int64Constant(0)),
+ &a, &b);
+ m.Bind(&a);
+ m.Return(m.Int64Constant(1));
+ m.Bind(&b);
+ m.Return(m.Int64Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64TestAndBranch, s[0]->arch_opcode());
+ EXPECT_EQ(kNotEqual, s[0]->flags_condition());
+ EXPECT_EQ(4U, s[0]->InputCount());
+ EXPECT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ EXPECT_EQ(bit, s.ToInt64(s[0]->InputAt(1)));
+ }
+}
TEST_F(InstructionSelectorTest, CompareAgainstZeroAndBranch) {
{
@@ -1298,6 +1385,75 @@
}
}
+TEST_F(InstructionSelectorTest, EqualZeroAndBranch) {
+ {
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Int32());
+ RawMachineLabel a, b;
+ Node* p0 = m.Parameter(0);
+ m.Branch(m.Word32Equal(p0, m.Int32Constant(0)), &a, &b);
+ m.Bind(&a);
+ m.Return(m.Int32Constant(1));
+ m.Bind(&b);
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64CompareAndBranch32, s[0]->arch_opcode());
+ EXPECT_EQ(kEqual, s[0]->flags_condition());
+ EXPECT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ }
+
+ {
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Int32());
+ RawMachineLabel a, b;
+ Node* p0 = m.Parameter(0);
+ m.Branch(m.Word32NotEqual(p0, m.Int32Constant(0)), &a, &b);
+ m.Bind(&a);
+ m.Return(m.Int32Constant(1));
+ m.Bind(&b);
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64CompareAndBranch32, s[0]->arch_opcode());
+ EXPECT_EQ(kNotEqual, s[0]->flags_condition());
+ EXPECT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ }
+
+ {
+ StreamBuilder m(this, MachineType::Int64(), MachineType::Int64());
+ RawMachineLabel a, b;
+ Node* p0 = m.Parameter(0);
+ m.Branch(m.Word64Equal(p0, m.Int64Constant(0)), &a, &b);
+ m.Bind(&a);
+ m.Return(m.Int64Constant(1));
+ m.Bind(&b);
+ m.Return(m.Int64Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64CompareAndBranch, s[0]->arch_opcode());
+ EXPECT_EQ(kEqual, s[0]->flags_condition());
+ EXPECT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ }
+
+ {
+ StreamBuilder m(this, MachineType::Int64(), MachineType::Int64());
+ RawMachineLabel a, b;
+ Node* p0 = m.Parameter(0);
+ m.Branch(m.Word64NotEqual(p0, m.Int64Constant(0)), &a, &b);
+ m.Bind(&a);
+ m.Return(m.Int64Constant(1));
+ m.Bind(&b);
+ m.Return(m.Int64Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64CompareAndBranch, s[0]->arch_opcode());
+ EXPECT_EQ(kNotEqual, s[0]->flags_condition());
+ EXPECT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ }
+}
// -----------------------------------------------------------------------------
// Add and subtract instructions with overflow.
@@ -1453,6 +1609,29 @@
}
}
+TEST_P(InstructionSelectorOvfAddSubTest, RORShift) {
+ // ADD and SUB do not support ROR shifts, make sure we do not try
+ // to merge them into the ADD/SUB instruction.
+ const MachInst2 dpi = GetParam();
+ const MachineType type = dpi.machine_type;
+ auto rotate = &RawMachineAssembler::Word64Ror;
+ ArchOpcode rotate_opcode = kArm64Ror;
+ if (type == MachineType::Int32()) {
+ rotate = &RawMachineAssembler::Word32Ror;
+ rotate_opcode = kArm64Ror32;
+ }
+ TRACED_FORRANGE(int32_t, imm, -32, 63) {
+ StreamBuilder m(this, type, type, type);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* r = (m.*rotate)(p1, m.Int32Constant(imm));
+ m.Return((m.*dpi.constructor)(p0, r));
+ Stream s = m.Build();
+ ASSERT_EQ(2U, s.size());
+ EXPECT_EQ(rotate_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(dpi.arch_opcode, s[1]->arch_opcode());
+ }
+}
INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
InstructionSelectorOvfAddSubTest,
@@ -2846,6 +3025,7 @@
struct IntegerCmp {
MachInst2 mi;
FlagsCondition cond;
+ FlagsCondition commuted_cond;
};
@@ -2858,19 +3038,24 @@
const IntegerCmp kIntegerCmpInstructions[] = {
{{&RawMachineAssembler::Word32Equal, "Word32Equal", kArm64Cmp32,
MachineType::Int32()},
+ kEqual,
kEqual},
{{&RawMachineAssembler::Int32LessThan, "Int32LessThan", kArm64Cmp32,
MachineType::Int32()},
- kSignedLessThan},
+ kSignedLessThan,
+ kSignedGreaterThan},
{{&RawMachineAssembler::Int32LessThanOrEqual, "Int32LessThanOrEqual",
kArm64Cmp32, MachineType::Int32()},
- kSignedLessThanOrEqual},
+ kSignedLessThanOrEqual,
+ kSignedGreaterThanOrEqual},
{{&RawMachineAssembler::Uint32LessThan, "Uint32LessThan", kArm64Cmp32,
MachineType::Uint32()},
- kUnsignedLessThan},
+ kUnsignedLessThan,
+ kUnsignedGreaterThan},
{{&RawMachineAssembler::Uint32LessThanOrEqual, "Uint32LessThanOrEqual",
kArm64Cmp32, MachineType::Uint32()},
- kUnsignedLessThanOrEqual}};
+ kUnsignedLessThanOrEqual,
+ kUnsignedGreaterThanOrEqual}};
} // namespace
@@ -2907,6 +3092,156 @@
}
}
+TEST_F(InstructionSelectorTest, CmpWithImmediateOnLeft) {
+ TRACED_FOREACH(IntegerCmp, cmp, kIntegerCmpInstructions) {
+ TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
+ // kEqual and kNotEqual trigger the cbz/cbnz optimization, which
+ // is tested elsewhere.
+ if (cmp.cond == kEqual || cmp.cond == kNotEqual) continue;
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Int32());
+ Node* const p0 = m.Parameter(0);
+ RawMachineLabel a, b;
+ m.Branch((m.*cmp.mi.constructor)(m.Int32Constant(imm), p0), &a, &b);
+ m.Bind(&a);
+ m.Return(m.Int32Constant(1));
+ m.Bind(&b);
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Cmp32, s[0]->arch_opcode());
+ ASSERT_LE(2U, s[0]->InputCount());
+ EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
+ EXPECT_EQ(cmp.commuted_cond, s[0]->flags_condition());
+ EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
+ }
+ }
+}
+
+TEST_F(InstructionSelectorTest, CmnWithImmediateOnLeft) {
+ TRACED_FOREACH(IntegerCmp, cmp, kIntegerCmpInstructions) {
+ TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
+ // kEqual and kNotEqual trigger the cbz/cbnz optimization, which
+ // is tested elsewhere.
+ if (cmp.cond == kEqual || cmp.cond == kNotEqual) continue;
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Int32());
+ Node* sub = m.Int32Sub(m.Int32Constant(0), m.Parameter(0));
+ RawMachineLabel a, b;
+ m.Branch((m.*cmp.mi.constructor)(m.Int32Constant(imm), sub), &a, &b);
+ m.Bind(&a);
+ m.Return(m.Int32Constant(1));
+ m.Bind(&b);
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Cmn32, s[0]->arch_opcode());
+ ASSERT_LE(2U, s[0]->InputCount());
+ EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
+ EXPECT_EQ(cmp.cond, s[0]->flags_condition());
+ EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
+ }
+ }
+}
+
+TEST_F(InstructionSelectorTest, CmpSignedExtendByteOnLeft) {
+ TRACED_FOREACH(IntegerCmp, cmp, kIntegerCmpInstructions) {
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Int32(),
+ MachineType::Int32());
+ Node* extend = m.Word32Sar(m.Word32Shl(m.Parameter(0), m.Int32Constant(24)),
+ m.Int32Constant(24));
+ m.Return((m.*cmp.mi.constructor)(extend, m.Parameter(1)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Cmp32, s[0]->arch_opcode());
+ EXPECT_EQ(kFlags_set, s[0]->flags_mode());
+ EXPECT_EQ(cmp.commuted_cond, s[0]->flags_condition());
+ EXPECT_EQ(kMode_Operand2_R_SXTB, s[0]->addressing_mode());
+ }
+}
+
+TEST_F(InstructionSelectorTest, CmnSignedExtendByteOnLeft) {
+ TRACED_FOREACH(IntegerCmp, cmp, kIntegerCmpInstructions) {
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Int32(),
+ MachineType::Int32());
+ Node* sub = m.Int32Sub(m.Int32Constant(0), m.Parameter(0));
+ Node* extend = m.Word32Sar(m.Word32Shl(m.Parameter(0), m.Int32Constant(24)),
+ m.Int32Constant(24));
+ m.Return((m.*cmp.mi.constructor)(extend, sub));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Cmn32, s[0]->arch_opcode());
+ EXPECT_EQ(kFlags_set, s[0]->flags_mode());
+ EXPECT_EQ(cmp.cond, s[0]->flags_condition());
+ EXPECT_EQ(kMode_Operand2_R_SXTB, s[0]->addressing_mode());
+ }
+}
+
+TEST_F(InstructionSelectorTest, CmpShiftByImmediateOnLeft) {
+ TRACED_FOREACH(IntegerCmp, cmp, kIntegerCmpInstructions) {
+ TRACED_FOREACH(Shift, shift, kShiftInstructions) {
+ // Only test relevant shifted operands.
+ if (shift.mi.machine_type != MachineType::Int32()) continue;
+
+ // The available shift operand range is `0 <= imm < 32`, but we also test
+ // that immediates outside this range are handled properly (modulo-32).
+ TRACED_FORRANGE(int, imm, -32, 63) {
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Int32(),
+ MachineType::Int32());
+ m.Return((m.*cmp.mi.constructor)(
+ (m.*shift.mi.constructor)(m.Parameter(1), m.Int32Constant(imm)),
+ m.Parameter(0)));
+ Stream s = m.Build();
+ // Cmp does not support ROR shifts.
+ if (shift.mi.arch_opcode == kArm64Ror32) {
+ ASSERT_EQ(2U, s.size());
+ continue;
+ }
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Cmp32, s[0]->arch_opcode());
+ EXPECT_EQ(shift.mode, s[0]->addressing_mode());
+ EXPECT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(imm, s.ToInt64(s[0]->InputAt(2)));
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(kFlags_set, s[0]->flags_mode());
+ EXPECT_EQ(cmp.commuted_cond, s[0]->flags_condition());
+ }
+ }
+ }
+}
+
+TEST_F(InstructionSelectorTest, CmnShiftByImmediateOnLeft) {
+ TRACED_FOREACH(IntegerCmp, cmp, kIntegerCmpInstructions) {
+ TRACED_FOREACH(Shift, shift, kShiftInstructions) {
+ // Only test relevant shifted operands.
+ if (shift.mi.machine_type != MachineType::Int32()) continue;
+
+ // The available shift operand range is `0 <= imm < 32`, but we also test
+ // that immediates outside this range are handled properly (modulo-32).
+ TRACED_FORRANGE(int, imm, -32, 63) {
+ StreamBuilder m(this, MachineType::Int32(), MachineType::Int32(),
+ MachineType::Int32());
+ Node* sub = m.Int32Sub(m.Int32Constant(0), m.Parameter(0));
+ m.Return((m.*cmp.mi.constructor)(
+ (m.*shift.mi.constructor)(m.Parameter(1), m.Int32Constant(imm)),
+ sub));
+ Stream s = m.Build();
+ // Cmn does not support ROR shifts.
+ if (shift.mi.arch_opcode == kArm64Ror32) {
+ ASSERT_EQ(2U, s.size());
+ continue;
+ }
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Cmn32, s[0]->arch_opcode());
+ EXPECT_EQ(shift.mode, s[0]->addressing_mode());
+ EXPECT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(imm, s.ToInt64(s[0]->InputAt(2)));
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(kFlags_set, s[0]->flags_mode());
+ EXPECT_EQ(cmp.cond, s[0]->flags_condition());
+ }
+ }
+ }
+}
+
// -----------------------------------------------------------------------------
// Miscellaneous
@@ -3574,6 +3909,36 @@
EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
}
+TEST_F(InstructionSelectorTest, Float32Neg) {
+ StreamBuilder m(this, MachineType::Float32(), MachineType::Float32());
+ Node* const p0 = m.Parameter(0);
+ // Don't use m.Float32Neg() as that generates an explicit sub.
+ Node* const n = m.AddNode(m.machine()->Float32Neg().op(), m.Parameter(0));
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Float32Neg, s[0]->arch_opcode());
+ ASSERT_EQ(1U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+}
+
+TEST_F(InstructionSelectorTest, Float64Neg) {
+ StreamBuilder m(this, MachineType::Float64(), MachineType::Float64());
+ Node* const p0 = m.Parameter(0);
+ // Don't use m.Float64Neg() as that generates an explicit sub.
+ Node* const n = m.AddNode(m.machine()->Float64Neg().op(), m.Parameter(0));
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Float64Neg, s[0]->arch_opcode());
+ ASSERT_EQ(1U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
diff --git a/test/unittests/compiler/checkpoint-elimination-unittest.cc b/test/unittests/compiler/checkpoint-elimination-unittest.cc
new file mode 100644
index 0000000..a201fc9
--- /dev/null
+++ b/test/unittests/compiler/checkpoint-elimination-unittest.cc
@@ -0,0 +1,59 @@
+// 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/compiler/checkpoint-elimination.h"
+#include "src/compiler/common-operator.h"
+#include "src/compiler/operator.h"
+#include "test/unittests/compiler/graph-reducer-unittest.h"
+#include "test/unittests/compiler/graph-unittest.h"
+#include "test/unittests/compiler/node-test-utils.h"
+
+using testing::StrictMock;
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class CheckpointEliminationTest : public GraphTest {
+ public:
+ CheckpointEliminationTest() : GraphTest() {}
+ ~CheckpointEliminationTest() override {}
+
+ protected:
+ Reduction Reduce(AdvancedReducer::Editor* editor, Node* node) {
+ CheckpointElimination reducer(editor);
+ return reducer.Reduce(node);
+ }
+
+ Reduction Reduce(Node* node) {
+ StrictMock<MockAdvancedReducerEditor> editor;
+ return Reduce(&editor, node);
+ }
+};
+
+namespace {
+
+const Operator kOpNoWrite(0, Operator::kNoWrite, "OpNoWrite", 0, 1, 0, 0, 1, 0);
+
+} // namespace
+
+// -----------------------------------------------------------------------------
+// Checkpoint
+
+TEST_F(CheckpointEliminationTest, CheckpointChain) {
+ Node* const control = graph()->start();
+ Node* frame_state = EmptyFrameState();
+ Node* checkpoint1 = graph()->NewNode(common()->Checkpoint(), frame_state,
+ graph()->start(), control);
+ Node* effect_link = graph()->NewNode(&kOpNoWrite, checkpoint1);
+ Node* checkpoint2 = graph()->NewNode(common()->Checkpoint(), frame_state,
+ effect_link, control);
+ Reduction r = Reduce(checkpoint2);
+ ASSERT_TRUE(r.Changed());
+ EXPECT_EQ(effect_link, r.replacement());
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
diff --git a/test/unittests/compiler/coalesced-live-ranges-unittest.cc b/test/unittests/compiler/coalesced-live-ranges-unittest.cc
deleted file mode 100644
index fe8fac4..0000000
--- a/test/unittests/compiler/coalesced-live-ranges-unittest.cc
+++ /dev/null
@@ -1,268 +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 "src/compiler/coalesced-live-ranges.h"
-#include "test/unittests/compiler/live-range-builder.h"
-#include "test/unittests/test-utils.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-
-class CoalescedLiveRangesTest : public TestWithZone {
- public:
- CoalescedLiveRangesTest() : TestWithZone(), ranges_(zone()) {}
- bool HasNoConflicts(const LiveRange* range);
- bool ConflictsPreciselyWith(const LiveRange* range, int id);
- bool ConflictsPreciselyWith(const LiveRange* range, int id1, int id2);
-
- CoalescedLiveRanges& ranges() { return ranges_; }
- const CoalescedLiveRanges& ranges() const { return ranges_; }
- bool AllocationsAreValid() const;
- void RemoveConflicts(LiveRange* range);
-
- private:
- typedef ZoneSet<int> LiveRangeIDs;
- bool IsRangeConflictingWith(const LiveRange* range, const LiveRangeIDs& ids);
- CoalescedLiveRanges ranges_;
-};
-
-
-bool CoalescedLiveRangesTest::ConflictsPreciselyWith(const LiveRange* range,
- int id) {
- LiveRangeIDs set(zone());
- set.insert(id);
- return IsRangeConflictingWith(range, set);
-}
-
-
-bool CoalescedLiveRangesTest::ConflictsPreciselyWith(const LiveRange* range,
- int id1, int id2) {
- LiveRangeIDs set(zone());
- set.insert(id1);
- set.insert(id2);
- return IsRangeConflictingWith(range, set);
-}
-
-
-bool CoalescedLiveRangesTest::HasNoConflicts(const LiveRange* range) {
- LiveRangeIDs set(zone());
- return IsRangeConflictingWith(range, set);
-}
-
-
-void CoalescedLiveRangesTest::RemoveConflicts(LiveRange* range) {
- auto conflicts = ranges().GetConflicts(range);
- LiveRangeIDs seen(zone());
- for (auto c = conflicts.Current(); c != nullptr;
- c = conflicts.RemoveCurrentAndGetNext()) {
- int id = c->TopLevel()->vreg();
- EXPECT_FALSE(seen.count(id) > 0);
- seen.insert(c->TopLevel()->vreg());
- }
-}
-
-
-bool CoalescedLiveRangesTest::AllocationsAreValid() const {
- return ranges().VerifyAllocationsAreValidForTesting();
-}
-
-
-bool CoalescedLiveRangesTest::IsRangeConflictingWith(const LiveRange* range,
- const LiveRangeIDs& ids) {
- LiveRangeIDs found_ids(zone());
-
- auto conflicts = ranges().GetConflicts(range);
- for (auto conflict = conflicts.Current(); conflict != nullptr;
- conflict = conflicts.GetNext()) {
- found_ids.insert(conflict->TopLevel()->vreg());
- }
- return found_ids == ids;
-}
-
-
-TEST_F(CoalescedLiveRangesTest, VisitEmptyAllocations) {
- LiveRange* range = TestRangeBuilder(zone()).Id(1).Build(1, 5);
- ASSERT_TRUE(ranges().empty());
- ASSERT_TRUE(AllocationsAreValid());
- ASSERT_TRUE(HasNoConflicts(range));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, CandidateBeforeAfterAllocations) {
- LiveRange* range = TestRangeBuilder(zone()).Id(1).Build(5, 6);
- ranges().AllocateRange(range);
- ASSERT_FALSE(ranges().empty());
- ASSERT_TRUE(AllocationsAreValid());
- LiveRange* query = TestRangeBuilder(zone()).Id(2).Build(1, 2);
- ASSERT_TRUE(HasNoConflicts(query));
- query = TestRangeBuilder(zone()).Id(3).Build(1, 5);
- ASSERT_TRUE(HasNoConflicts(query));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, CandidateBeforeAfterManyAllocations) {
- LiveRange* range =
- TestRangeBuilder(zone()).Id(1).Add(5, 7).Add(10, 12).Build();
- ranges().AllocateRange(range);
- ASSERT_FALSE(ranges().empty());
- ASSERT_TRUE(AllocationsAreValid());
- LiveRange* query =
- TestRangeBuilder(zone()).Id(2).Add(1, 2).Add(13, 15).Build();
- ASSERT_TRUE(HasNoConflicts(query));
- query = TestRangeBuilder(zone()).Id(3).Add(1, 5).Add(12, 15).Build();
- ASSERT_TRUE(HasNoConflicts(query));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, SelfConflictsPreciselyWithSelf) {
- LiveRange* range = TestRangeBuilder(zone()).Id(1).Build(1, 5);
- ranges().AllocateRange(range);
- ASSERT_FALSE(ranges().empty());
- ASSERT_TRUE(AllocationsAreValid());
- ASSERT_TRUE(ConflictsPreciselyWith(range, 1));
- range = TestRangeBuilder(zone()).Id(2).Build(8, 10);
- ranges().AllocateRange(range);
- ASSERT_TRUE(ConflictsPreciselyWith(range, 2));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, QueryStartsBeforeConflict) {
- LiveRange* range = TestRangeBuilder(zone()).Id(1).Build(2, 5);
- ranges().AllocateRange(range);
- LiveRange* query = TestRangeBuilder(zone()).Id(2).Build(1, 3);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 1));
- range = TestRangeBuilder(zone()).Id(3).Build(8, 10);
- ranges().AllocateRange(range);
- query = TestRangeBuilder(zone()).Id(4).Build(6, 9);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 3));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, QueryStartsInConflict) {
- LiveRange* range = TestRangeBuilder(zone()).Id(1).Build(2, 5);
- ranges().AllocateRange(range);
- LiveRange* query = TestRangeBuilder(zone()).Id(2).Build(3, 6);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 1));
- range = TestRangeBuilder(zone()).Id(3).Build(8, 10);
- ranges().AllocateRange(range);
- query = TestRangeBuilder(zone()).Id(4).Build(9, 11);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 3));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, QueryContainedInConflict) {
- LiveRange* range = TestRangeBuilder(zone()).Id(1).Build(1, 5);
- ranges().AllocateRange(range);
- LiveRange* query = TestRangeBuilder(zone()).Id(2).Build(2, 3);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 1));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, QueryContainsConflict) {
- LiveRange* range = TestRangeBuilder(zone()).Id(1).Build(2, 3);
- ranges().AllocateRange(range);
- LiveRange* query = TestRangeBuilder(zone()).Id(2).Build(1, 5);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 1));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, QueryCoversManyIntervalsSameRange) {
- LiveRange* range =
- TestRangeBuilder(zone()).Id(1).Add(1, 5).Add(7, 9).Add(20, 25).Build();
- ranges().AllocateRange(range);
- LiveRange* query = TestRangeBuilder(zone()).Id(2).Build(2, 8);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 1));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, QueryCoversManyIntervalsDifferentRanges) {
- LiveRange* range =
- TestRangeBuilder(zone()).Id(1).Add(1, 5).Add(20, 25).Build();
- ranges().AllocateRange(range);
- range = TestRangeBuilder(zone()).Id(2).Build(7, 10);
- ranges().AllocateRange(range);
- LiveRange* query = TestRangeBuilder(zone()).Id(3).Build(2, 22);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 1, 2));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, QueryFitsInGaps) {
- LiveRange* range =
- TestRangeBuilder(zone()).Id(1).Add(1, 5).Add(10, 15).Add(20, 25).Build();
- ranges().AllocateRange(range);
- LiveRange* query =
- TestRangeBuilder(zone()).Id(3).Add(5, 10).Add(16, 19).Add(27, 30).Build();
- ASSERT_TRUE(HasNoConflicts(query));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, DeleteConflictBefore) {
- LiveRange* range = TestRangeBuilder(zone()).Id(1).Add(1, 4).Add(5, 6).Build();
- ranges().AllocateRange(range);
- range = TestRangeBuilder(zone()).Id(2).Build(40, 50);
- ranges().AllocateRange(range);
- LiveRange* query = TestRangeBuilder(zone()).Id(3).Build(3, 7);
- RemoveConflicts(query);
- query = TestRangeBuilder(zone()).Id(4).Build(0, 60);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 2));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, DeleteConflictAfter) {
- LiveRange* range = TestRangeBuilder(zone()).Id(1).Build(1, 5);
- ranges().AllocateRange(range);
- range = TestRangeBuilder(zone()).Id(2).Add(40, 50).Add(60, 70).Build();
- ranges().AllocateRange(range);
- LiveRange* query = TestRangeBuilder(zone()).Id(3).Build(45, 60);
- RemoveConflicts(query);
- query = TestRangeBuilder(zone()).Id(4).Build(0, 60);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 1));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, DeleteConflictStraddle) {
- LiveRange* range =
- TestRangeBuilder(zone()).Id(1).Add(1, 5).Add(10, 20).Build();
- ranges().AllocateRange(range);
- range = TestRangeBuilder(zone()).Id(2).Build(40, 50);
- ranges().AllocateRange(range);
- LiveRange* query = TestRangeBuilder(zone()).Id(3).Build(4, 15);
- RemoveConflicts(query);
- query = TestRangeBuilder(zone()).Id(4).Build(0, 60);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 2));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, DeleteConflictManyOverlapsBefore) {
- LiveRange* range =
- TestRangeBuilder(zone()).Id(1).Add(1, 5).Add(6, 10).Add(10, 20).Build();
- ranges().AllocateRange(range);
- range = TestRangeBuilder(zone()).Id(2).Build(40, 50);
- ranges().AllocateRange(range);
- LiveRange* query = TestRangeBuilder(zone()).Id(3).Build(4, 15);
- RemoveConflicts(query);
- query = TestRangeBuilder(zone()).Id(4).Build(0, 60);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 2));
-}
-
-
-TEST_F(CoalescedLiveRangesTest, DeleteWhenConflictRepeatsAfterNonConflict) {
- LiveRange* range =
- TestRangeBuilder(zone()).Id(1).Add(1, 5).Add(6, 10).Add(20, 30).Build();
- ranges().AllocateRange(range);
- range = TestRangeBuilder(zone()).Id(2).Build(12, 15);
- ranges().AllocateRange(range);
- LiveRange* query =
- TestRangeBuilder(zone()).Id(3).Add(1, 8).Add(22, 25).Build();
- RemoveConflicts(query);
- query = TestRangeBuilder(zone()).Id(4).Build(0, 60);
- ASSERT_TRUE(ConflictsPreciselyWith(query, 2));
-}
-
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
diff --git a/test/unittests/compiler/common-operator-unittest.cc b/test/unittests/compiler/common-operator-unittest.cc
index 0a55a2e..52f99a5 100644
--- a/test/unittests/compiler/common-operator-unittest.cc
+++ b/test/unittests/compiler/common-operator-unittest.cc
@@ -362,15 +362,26 @@
TEST_F(CommonOperatorTest, BeginRegion) {
- const Operator* op = common()->BeginRegion();
- EXPECT_EQ(1, op->EffectInputCount());
- EXPECT_EQ(1, OperatorProperties::GetTotalInputCount(op));
- EXPECT_EQ(0, op->ControlOutputCount());
- EXPECT_EQ(1, op->EffectOutputCount());
- EXPECT_EQ(0, op->ValueOutputCount());
+ {
+ const Operator* op =
+ common()->BeginRegion(RegionObservability::kObservable);
+ EXPECT_EQ(1, op->EffectInputCount());
+ EXPECT_EQ(1, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(0, op->ControlOutputCount());
+ EXPECT_EQ(1, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ValueOutputCount());
+ }
+ {
+ const Operator* op =
+ common()->BeginRegion(RegionObservability::kNotObservable);
+ EXPECT_EQ(1, op->EffectInputCount());
+ EXPECT_EQ(1, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(0, op->ControlOutputCount());
+ EXPECT_EQ(1, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ValueOutputCount());
+ }
}
-
TEST_F(CommonOperatorTest, FinishRegion) {
const Operator* op = common()->FinishRegion();
EXPECT_EQ(1, op->ValueInputCount());
@@ -381,6 +392,19 @@
EXPECT_EQ(1, op->ValueOutputCount());
}
+TEST_F(CommonOperatorTest, Projection) {
+ TRACED_FORRANGE(size_t, index, 0, 3) {
+ const Operator* op = common()->Projection(index);
+ EXPECT_EQ(index, ProjectionIndexOf(op));
+ EXPECT_EQ(1, op->ValueInputCount());
+ EXPECT_EQ(1, op->ControlInputCount());
+ EXPECT_EQ(2, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(0, op->ControlOutputCount());
+ EXPECT_EQ(0, op->EffectOutputCount());
+ EXPECT_EQ(1, op->ValueOutputCount());
+ }
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
diff --git a/test/unittests/compiler/escape-analysis-unittest.cc b/test/unittests/compiler/escape-analysis-unittest.cc
index 4c17ef2..9b584a2 100644
--- a/test/unittests/compiler/escape-analysis-unittest.cc
+++ b/test/unittests/compiler/escape-analysis-unittest.cc
@@ -48,7 +48,8 @@
effect = effect_;
}
- return effect_ = graph()->NewNode(common()->BeginRegion(), effect);
+ return effect_ = graph()->NewNode(
+ common()->BeginRegion(RegionObservability::kObservable), effect);
}
Node* FinishRegion(Node* value, Node* effect = nullptr) {
diff --git a/test/unittests/compiler/graph-unittest.h b/test/unittests/compiler/graph-unittest.h
index 31bae6d..d4248e4 100644
--- a/test/unittests/compiler/graph-unittest.h
+++ b/test/unittests/compiler/graph-unittest.h
@@ -48,6 +48,9 @@
Node* EmptyFrameState();
+ Matcher<Node*> IsBooleanConstant(bool value) {
+ return value ? IsTrueConstant() : IsFalseConstant();
+ }
Matcher<Node*> IsFalseConstant();
Matcher<Node*> IsTrueConstant();
Matcher<Node*> IsUndefinedConstant();
diff --git a/test/unittests/compiler/instruction-selector-unittest.cc b/test/unittests/compiler/instruction-selector-unittest.cc
index 69ae768..936a94e 100644
--- a/test/unittests/compiler/instruction-selector-unittest.cc
+++ b/test/unittests/compiler/instruction-selector-unittest.cc
@@ -45,9 +45,8 @@
selector.SelectInstructions();
if (FLAG_trace_turbo) {
OFStream out(stdout);
- PrintableInstructionSequence printable = {
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN),
- &sequence};
+ PrintableInstructionSequence printable = {RegisterConfiguration::Turbofan(),
+ &sequence};
out << "=== Code sequence after instruction selection ===" << std::endl
<< printable;
}
@@ -94,12 +93,12 @@
}
for (auto i : s.virtual_registers_) {
int const virtual_register = i.second;
- if (sequence.IsFloat(virtual_register)) {
+ if (sequence.IsFP(virtual_register)) {
EXPECT_FALSE(sequence.IsReference(virtual_register));
s.doubles_.insert(virtual_register);
}
if (sequence.IsReference(virtual_register)) {
- EXPECT_FALSE(sequence.IsFloat(virtual_register));
+ EXPECT_FALSE(sequence.IsFP(virtual_register));
s.references_.insert(virtual_register);
}
}
@@ -333,7 +332,8 @@
Node* p2 = m2.Parameter(0);
m2.Return(m2.AddNode(
m2.machine()->Load(MachineType::Int32()), p2, m2.Int32Constant(0),
- m2.AddNode(m2.common()->BeginRegion(), m2.graph()->start())));
+ m2.AddNode(m2.common()->BeginRegion(RegionObservability::kObservable),
+ m2.graph()->start())));
Stream s2 = m2.Build(kAllInstructions);
EXPECT_LE(3U, s1.size());
ASSERT_EQ(s1.size(), s2.size());
@@ -480,7 +480,7 @@
EXPECT_EQ(0, s.ToInt32(call_instr->InputAt(4))); // This should be a context.
// We inserted 0 here.
EXPECT_EQ(0.5, s.ToFloat64(call_instr->InputAt(5)));
- EXPECT_TRUE(s.ToHeapObject(call_instr->InputAt(6))->IsUndefined());
+ EXPECT_TRUE(s.ToHeapObject(call_instr->InputAt(6))->IsUndefined(isolate()));
EXPECT_EQ(MachineType::AnyTagged(),
desc_before->GetType(0)); // function is always
// tagged/any.
diff --git a/test/unittests/compiler/instruction-sequence-unittest.cc b/test/unittests/compiler/instruction-sequence-unittest.cc
index 9360ca4..619e0aa 100644
--- a/test/unittests/compiler/instruction-sequence-unittest.cc
+++ b/test/unittests/compiler/instruction-sequence-unittest.cc
@@ -67,8 +67,11 @@
if (config_.is_empty()) {
config_.Reset(new RegisterConfiguration(
num_general_registers_, num_double_registers_, num_general_registers_,
- num_double_registers_, num_double_registers_, allocatable_codes,
- allocatable_double_codes, general_register_names_,
+ num_double_registers_, allocatable_codes, allocatable_double_codes,
+ kSimpleFPAliasing ? RegisterConfiguration::OVERLAP
+ : RegisterConfiguration::COMBINE,
+ general_register_names_,
+ double_register_names_, // float register names
double_register_names_));
}
return config_.get();
diff --git a/test/unittests/compiler/int64-lowering-unittest.cc b/test/unittests/compiler/int64-lowering-unittest.cc
index 8bc02c5..804c399 100644
--- a/test/unittests/compiler/int64-lowering-unittest.cc
+++ b/test/unittests/compiler/int64-lowering-unittest.cc
@@ -133,6 +133,7 @@
MachineRepresentation::kWord64);
Capture<Node*> high_word_load;
+#if defined(V8_TARGET_LITTLE_ENDIAN)
Matcher<Node*> high_word_load_matcher =
IsLoad(MachineType::Int32(), IsInt32Constant(base),
IsInt32Add(IsInt32Constant(index), IsInt32Constant(0x4)), start(),
@@ -146,6 +147,21 @@
start()),
AllOf(CaptureEq(&high_word_load), high_word_load_matcher),
start(), start()));
+#elif defined(V8_TARGET_BIG_ENDIAN)
+ Matcher<Node*> high_word_load_matcher =
+ IsLoad(MachineType::Int32(), IsInt32Constant(base),
+ IsInt32Constant(index), start(), start());
+
+ EXPECT_THAT(
+ graph()->end()->InputAt(1),
+ IsReturn2(
+ IsLoad(MachineType::Int32(), IsInt32Constant(base),
+ IsInt32Add(IsInt32Constant(index), IsInt32Constant(0x4)),
+ AllOf(CaptureEq(&high_word_load), high_word_load_matcher),
+ start()),
+ AllOf(CaptureEq(&high_word_load), high_word_load_matcher), start(),
+ start()));
+#endif
}
TEST_F(Int64LoweringTest, Int64Store) {
@@ -177,6 +193,7 @@
const StoreRepresentation rep(MachineRepresentation::kWord32,
kNoWriteBarrier);
+#if defined(V8_TARGET_LITTLE_ENDIAN)
EXPECT_THAT(
graph()->end()->InputAt(1),
IsReturn(
@@ -189,6 +206,20 @@
IsInt32Constant(high_word_value(0)), start(), start()),
start()),
start()));
+#elif defined(V8_TARGET_BIG_ENDIAN)
+ EXPECT_THAT(
+ graph()->end()->InputAt(1),
+ IsReturn(
+ IsInt32Constant(return_value),
+ IsStore(
+ rep, IsInt32Constant(base),
+ IsInt32Add(IsInt32Constant(index), IsInt32Constant(4)),
+ IsInt32Constant(low_word_value(0)),
+ IsStore(rep, IsInt32Constant(base), IsInt32Constant(index),
+ IsInt32Constant(high_word_value(0)), start(), start()),
+ start()),
+ start()));
+#endif
}
TEST_F(Int64LoweringTest, Int64And) {
@@ -526,12 +557,13 @@
IsStore(StoreRepresentation(MachineRepresentation::kWord32,
WriteBarrierKind::kNoWriteBarrier),
AllOf(CaptureEq(&stack_slot_capture), stack_slot_matcher),
- IsInt32Constant(0), IsInt32Constant(low_word_value(0)),
+ IsInt32Constant(Int64Lowering::kLowerWordOffset),
+ IsInt32Constant(low_word_value(0)),
IsStore(StoreRepresentation(MachineRepresentation::kWord32,
WriteBarrierKind::kNoWriteBarrier),
AllOf(CaptureEq(&stack_slot_capture), stack_slot_matcher),
- IsInt32Constant(4), IsInt32Constant(high_word_value(0)),
- start(), start()),
+ IsInt32Constant(Int64Lowering::kHigherWordOffset),
+ IsInt32Constant(high_word_value(0)), start(), start()),
start());
EXPECT_THAT(
@@ -563,11 +595,11 @@
graph()->end()->InputAt(1),
IsReturn2(IsLoad(MachineType::Int32(),
AllOf(CaptureEq(&stack_slot), stack_slot_matcher),
- IsInt32Constant(0),
+ IsInt32Constant(Int64Lowering::kLowerWordOffset),
AllOf(CaptureEq(&store), store_matcher), start()),
IsLoad(MachineType::Int32(),
AllOf(CaptureEq(&stack_slot), stack_slot_matcher),
- IsInt32Constant(0x4),
+ IsInt32Constant(Int64Lowering::kHigherWordOffset),
AllOf(CaptureEq(&store), store_matcher), start()),
start(), start()));
}
diff --git a/test/unittests/compiler/js-builtin-reducer-unittest.cc b/test/unittests/compiler/js-builtin-reducer-unittest.cc
index 0f8eed7..9a1378a 100644
--- a/test/unittests/compiler/js-builtin-reducer-unittest.cc
+++ b/test/unittests/compiler/js-builtin-reducer-unittest.cc
@@ -49,6 +49,19 @@
return HeapConstant(f);
}
+ Node* StringFunction(const char* name) {
+ Handle<Object> m =
+ JSObject::GetProperty(
+ isolate()->global_object(),
+ isolate()->factory()->NewStringFromAsciiChecked("String"))
+ .ToHandleChecked();
+ Handle<JSFunction> f = Handle<JSFunction>::cast(
+ Object::GetProperty(
+ m, isolate()->factory()->NewStringFromAsciiChecked(name))
+ .ToHandleChecked());
+ return HeapConstant(f);
+ }
+
JSOperatorBuilder* javascript() { return &javascript_; }
private:
@@ -74,10 +87,519 @@
// -----------------------------------------------------------------------------
+// Math.abs
+
+TEST_F(JSBuiltinReducerTest, MathAbsWithNumber) {
+ Node* function = MathFunction("abs");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberAbs(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathAbsWithPlainPrimitive) {
+ Node* function = MathFunction("abs");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberAbs(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.atan
+
+TEST_F(JSBuiltinReducerTest, MathAtanWithNumber) {
+ Node* function = MathFunction("atan");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberAtan(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathAtanWithPlainPrimitive) {
+ Node* function = MathFunction("atan");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberAtan(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.atan2
+
+TEST_F(JSBuiltinReducerTest, MathAtan2WithNumber) {
+ Node* function = MathFunction("atan2");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ TRACED_FOREACH(Type*, t1, kNumberTypes) {
+ Node* p1 = Parameter(t1, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(4), function,
+ UndefinedConstant(), p0, p1, context,
+ frame_state, effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberAtan2(p0, p1));
+ }
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathAtan2WithPlainPrimitive) {
+ Node* function = MathFunction("atan2");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* p1 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(4), function,
+ UndefinedConstant(), p0, p1, context,
+ frame_state, effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberAtan2(IsPlainPrimitiveToNumber(p0),
+ IsPlainPrimitiveToNumber(p1)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.ceil
+
+TEST_F(JSBuiltinReducerTest, MathCeilWithNumber) {
+ Node* function = MathFunction("ceil");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberCeil(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathCeilWithPlainPrimitive) {
+ Node* function = MathFunction("ceil");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberCeil(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.clz32
+
+TEST_F(JSBuiltinReducerTest, MathClz32WithUnsigned32) {
+ Node* function = MathFunction("clz32");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::Unsigned32(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberClz32(p0));
+}
+
+TEST_F(JSBuiltinReducerTest, MathClz32WithNumber) {
+ Node* function = MathFunction("clz32");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::Number(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberClz32(IsNumberToUint32(p0)));
+}
+
+TEST_F(JSBuiltinReducerTest, MathClz32WithPlainPrimitive) {
+ Node* function = MathFunction("clz32");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsNumberClz32(IsNumberToUint32(IsPlainPrimitiveToNumber(p0))));
+}
+
+// -----------------------------------------------------------------------------
+// Math.cos
+
+TEST_F(JSBuiltinReducerTest, MathCosWithNumber) {
+ Node* function = MathFunction("cos");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberCos(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathCosWithPlainPrimitive) {
+ Node* function = MathFunction("cos");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberCos(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.exp
+
+TEST_F(JSBuiltinReducerTest, MathExpWithNumber) {
+ Node* function = MathFunction("exp");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberExp(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathExpWithPlainPrimitive) {
+ Node* function = MathFunction("exp");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberExp(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.floor
+
+TEST_F(JSBuiltinReducerTest, MathFloorWithNumber) {
+ Node* function = MathFunction("floor");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberFloor(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathFloorWithPlainPrimitive) {
+ Node* function = MathFunction("floor");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberFloor(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.fround
+
+TEST_F(JSBuiltinReducerTest, MathFroundWithNumber) {
+ Node* function = MathFunction("fround");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberFround(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathFroundWithPlainPrimitive) {
+ Node* function = MathFunction("fround");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberFround(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.imul
+
+TEST_F(JSBuiltinReducerTest, MathImulWithUnsigned32) {
+ Node* function = MathFunction("imul");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::Unsigned32(), 0);
+ Node* p1 = Parameter(Type::Unsigned32(), 1);
+ Node* call = graph()->NewNode(javascript()->CallFunction(4), function,
+ UndefinedConstant(), p0, p1, context,
+ frame_state, effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberImul(p0, p1));
+}
+
+TEST_F(JSBuiltinReducerTest, MathImulWithNumber) {
+ Node* function = MathFunction("imul");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::Number(), 0);
+ Node* p1 = Parameter(Type::Number(), 1);
+ Node* call = graph()->NewNode(javascript()->CallFunction(4), function,
+ UndefinedConstant(), p0, p1, context,
+ frame_state, effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsNumberImul(IsNumberToUint32(p0), IsNumberToUint32(p1)));
+}
+
+TEST_F(JSBuiltinReducerTest, MathImulWithPlainPrimitive) {
+ Node* function = MathFunction("imul");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* p1 = Parameter(Type::PlainPrimitive(), 1);
+ Node* call = graph()->NewNode(javascript()->CallFunction(4), function,
+ UndefinedConstant(), p0, p1, context,
+ frame_state, effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsNumberImul(IsNumberToUint32(IsPlainPrimitiveToNumber(p0)),
+ IsNumberToUint32(IsPlainPrimitiveToNumber(p1))));
+}
+
+// -----------------------------------------------------------------------------
+// Math.log
+
+TEST_F(JSBuiltinReducerTest, MathLogWithNumber) {
+ Node* function = MathFunction("log");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberLog(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathLogWithPlainPrimitive) {
+ Node* function = MathFunction("log");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberLog(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.log1p
+
+TEST_F(JSBuiltinReducerTest, MathLog1pWithNumber) {
+ Node* function = MathFunction("log1p");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberLog1p(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathLog1pWithPlainPrimitive) {
+ Node* function = MathFunction("log1p");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberLog1p(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
// Math.max
-
-TEST_F(JSBuiltinReducerTest, MathMax0) {
+TEST_F(JSBuiltinReducerTest, MathMaxWithNoArguments) {
Node* function = MathFunction("max");
Node* effect = graph()->start();
@@ -86,15 +608,14 @@
Node* frame_state = graph()->start();
Node* call = graph()->NewNode(javascript()->CallFunction(2), function,
UndefinedConstant(), context, frame_state,
- frame_state, effect, control);
+ effect, control);
Reduction r = Reduce(call);
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(), IsNumberConstant(-V8_INFINITY));
}
-
-TEST_F(JSBuiltinReducerTest, MathMax1) {
+TEST_F(JSBuiltinReducerTest, MathMaxWithNumber) {
Node* function = MathFunction("max");
Node* effect = graph()->start();
@@ -105,7 +626,7 @@
Node* p0 = Parameter(t0, 0);
Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
UndefinedConstant(), p0, context, frame_state,
- frame_state, effect, control);
+ effect, control);
Reduction r = Reduce(call);
ASSERT_TRUE(r.Changed());
@@ -113,8 +634,24 @@
}
}
+TEST_F(JSBuiltinReducerTest, MathMaxWithPlainPrimitive) {
+ Node* function = MathFunction("max");
-TEST_F(JSBuiltinReducerTest, MathMax2) {
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsPlainPrimitiveToNumber(p0));
+}
+
+TEST_F(JSBuiltinReducerTest, MathMaxWithIntegral32) {
Node* function = MathFunction("max");
Node* effect = graph()->start();
@@ -127,7 +664,7 @@
Node* p1 = Parameter(t1, 1);
Node* call = graph()->NewNode(javascript()->CallFunction(4), function,
UndefinedConstant(), p0, p1, context,
- frame_state, frame_state, effect, control);
+ frame_state, effect, control);
Reduction r = Reduce(call);
ASSERT_TRUE(r.Changed());
@@ -137,41 +674,27 @@
}
}
-
// -----------------------------------------------------------------------------
-// Math.imul
+// Math.min
-
-TEST_F(JSBuiltinReducerTest, MathImul) {
- Node* function = MathFunction("imul");
+TEST_F(JSBuiltinReducerTest, MathMinWithNoArguments) {
+ Node* function = MathFunction("min");
Node* effect = graph()->start();
Node* control = graph()->start();
Node* context = UndefinedConstant();
Node* frame_state = graph()->start();
- TRACED_FOREACH(Type*, t0, kNumberTypes) {
- TRACED_FOREACH(Type*, t1, kNumberTypes) {
- Node* p0 = Parameter(t0, 0);
- Node* p1 = Parameter(t1, 1);
- Node* call = graph()->NewNode(javascript()->CallFunction(4), function,
- UndefinedConstant(), p0, p1, context,
- frame_state, frame_state, effect, control);
- Reduction r = Reduce(call);
+ Node* call = graph()->NewNode(javascript()->CallFunction(2), function,
+ UndefinedConstant(), context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(),
- IsNumberImul(IsNumberToUint32(p0), IsNumberToUint32(p1)));
- }
- }
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberConstant(V8_INFINITY));
}
-
-// -----------------------------------------------------------------------------
-// Math.fround
-
-
-TEST_F(JSBuiltinReducerTest, MathFround) {
- Node* function = MathFunction("fround");
+TEST_F(JSBuiltinReducerTest, MathMinWithNumber) {
+ Node* function = MathFunction("min");
Node* effect = graph()->start();
Node* control = graph()->start();
@@ -181,14 +704,289 @@
Node* p0 = Parameter(t0, 0);
Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
UndefinedConstant(), p0, context, frame_state,
- frame_state, effect, control);
+ effect, control);
Reduction r = Reduce(call);
ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsTruncateFloat64ToFloat32(p0));
+ EXPECT_THAT(r.replacement(), p0);
}
}
+TEST_F(JSBuiltinReducerTest, MathMinWithPlainPrimitive) {
+ Node* function = MathFunction("min");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsPlainPrimitiveToNumber(p0));
+}
+
+TEST_F(JSBuiltinReducerTest, MathMinWithIntegral32) {
+ Node* function = MathFunction("min");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kIntegral32Types) {
+ TRACED_FOREACH(Type*, t1, kIntegral32Types) {
+ Node* p0 = Parameter(t0, 0);
+ Node* p1 = Parameter(t1, 1);
+ Node* call = graph()->NewNode(javascript()->CallFunction(4), function,
+ UndefinedConstant(), p0, p1, context,
+ frame_state, effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsSelect(MachineRepresentation::kNone,
+ IsNumberLessThan(p1, p0), p1, p0));
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Math.round
+
+TEST_F(JSBuiltinReducerTest, MathRoundWithNumber) {
+ Node* function = MathFunction("round");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberRound(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathRoundWithPlainPrimitive) {
+ Node* function = MathFunction("round");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberRound(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.sin
+
+TEST_F(JSBuiltinReducerTest, MathSinWithNumber) {
+ Node* function = MathFunction("sin");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberSin(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathSinWithPlainPrimitive) {
+ Node* function = MathFunction("sin");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberSin(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.sqrt
+
+TEST_F(JSBuiltinReducerTest, MathSqrtWithNumber) {
+ Node* function = MathFunction("sqrt");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberSqrt(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathSqrtWithPlainPrimitive) {
+ Node* function = MathFunction("sqrt");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberSqrt(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.tan
+
+TEST_F(JSBuiltinReducerTest, MathTanWithNumber) {
+ Node* function = MathFunction("tan");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberTan(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathTanWithPlainPrimitive) {
+ Node* function = MathFunction("tan");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberTan(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// Math.trunc
+
+TEST_F(JSBuiltinReducerTest, MathTruncWithNumber) {
+ Node* function = MathFunction("trunc");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberTrunc(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, MathTruncWithPlainPrimitive) {
+ Node* function = MathFunction("trunc");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberTrunc(IsPlainPrimitiveToNumber(p0)));
+}
+
+// -----------------------------------------------------------------------------
+// String.fromCharCode
+
+TEST_F(JSBuiltinReducerTest, StringFromCharCodeWithNumber) {
+ Node* function = StringFunction("fromCharCode");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsStringFromCharCode(p0));
+ }
+}
+
+TEST_F(JSBuiltinReducerTest, StringFromCharCodeWithPlainPrimitive) {
+ Node* function = StringFunction("fromCharCode");
+
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* context = UndefinedConstant();
+ Node* frame_state = graph()->start();
+ Node* p0 = Parameter(Type::PlainPrimitive(), 0);
+ Node* call = graph()->NewNode(javascript()->CallFunction(3), function,
+ UndefinedConstant(), p0, context, frame_state,
+ effect, control);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsStringFromCharCode(IsPlainPrimitiveToNumber(p0)));
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
diff --git a/test/unittests/compiler/js-create-lowering-unittest.cc b/test/unittests/compiler/js-create-lowering-unittest.cc
index 5d95d0d..6e6245d 100644
--- a/test/unittests/compiler/js-create-lowering-unittest.cc
+++ b/test/unittests/compiler/js-create-lowering-unittest.cc
@@ -139,7 +139,7 @@
Node* const context = UndefinedConstant();
Node* const effect = graph()->start();
Node* const control = graph()->start();
- Handle<SharedFunctionInfo> shared(isolate()->object_function()->shared());
+ Handle<SharedFunctionInfo> shared(isolate()->number_function()->shared());
Reduction r =
Reduce(graph()->NewNode(javascript()->CreateClosure(shared, NOT_TENURED),
context, effect, control));
diff --git a/test/unittests/compiler/js-intrinsic-lowering-unittest.cc b/test/unittests/compiler/js-intrinsic-lowering-unittest.cc
index 7c2f459..7024559 100644
--- a/test/unittests/compiler/js-intrinsic-lowering-unittest.cc
+++ b/test/unittests/compiler/js-intrinsic-lowering-unittest.cc
@@ -43,13 +43,6 @@
return reducer.Reduce(node);
}
- Node* EmptyFrameState() {
- MachineOperatorBuilder machine(zone());
- JSGraph jsgraph(isolate(), graph(), common(), javascript(), nullptr,
- &machine);
- return jsgraph.EmptyFrameState();
- }
-
JSOperatorBuilder* javascript() { return &javascript_; }
private:
@@ -58,27 +51,6 @@
// -----------------------------------------------------------------------------
-// %_ConstructDouble
-
-
-TEST_F(JSIntrinsicLoweringTest, InlineOptimizedConstructDouble) {
- Node* const input0 = Parameter(0);
- Node* const input1 = Parameter(1);
- Node* const context = Parameter(2);
- Node* const effect = graph()->start();
- Node* const control = graph()->start();
- Reduction const r = Reduce(graph()->NewNode(
- javascript()->CallRuntime(Runtime::kInlineConstructDouble, 2), input0,
- input1, context, effect, control));
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsFloat64InsertHighWord32(
- IsFloat64InsertLowWord32(
- IsNumberConstant(BitEq(0.0)), input1),
- input0));
-}
-
-
-// -----------------------------------------------------------------------------
// %_DoubleLo
diff --git a/test/unittests/compiler/js-operator-unittest.cc b/test/unittests/compiler/js-operator-unittest.cc
index 28df6a9..d5f30ef 100644
--- a/test/unittests/compiler/js-operator-unittest.cc
+++ b/test/unittests/compiler/js-operator-unittest.cc
@@ -40,22 +40,12 @@
control_input_count, value_output_count, effect_output_count, \
control_output_count \
}
- SHARED(Equal, Operator::kNoProperties, 2, 1, 1, 1, 1, 1, 2),
- SHARED(NotEqual, Operator::kNoProperties, 2, 1, 1, 1, 1, 1, 2),
- SHARED(StrictEqual, Operator::kPure, 2, 0, 0, 0, 1, 0, 0),
- SHARED(StrictNotEqual, Operator::kPure, 2, 0, 0, 0, 1, 0, 0),
- SHARED(LessThan, Operator::kNoProperties, 2, 2, 1, 1, 1, 1, 2),
- SHARED(GreaterThan, Operator::kNoProperties, 2, 2, 1, 1, 1, 1, 2),
- SHARED(LessThanOrEqual, Operator::kNoProperties, 2, 2, 1, 1, 1, 1, 2),
- SHARED(GreaterThanOrEqual, Operator::kNoProperties, 2, 2, 1, 1, 1, 1, 2),
SHARED(ToNumber, Operator::kNoProperties, 1, 1, 1, 1, 1, 1, 2),
SHARED(ToString, Operator::kNoProperties, 1, 1, 1, 1, 1, 1, 2),
SHARED(ToName, Operator::kNoProperties, 1, 1, 1, 1, 1, 1, 2),
SHARED(ToObject, Operator::kFoldable, 1, 1, 1, 1, 1, 1, 2),
SHARED(Create, Operator::kEliminatable, 2, 1, 1, 0, 1, 1, 0),
- SHARED(HasProperty, Operator::kNoProperties, 2, 1, 1, 1, 1, 1, 2),
SHARED(TypeOf, Operator::kPure, 1, 0, 0, 0, 1, 0, 0),
- SHARED(InstanceOf, Operator::kNoProperties, 2, 1, 1, 1, 1, 1, 2),
SHARED(CreateWithContext, Operator::kNoProperties, 2, 0, 1, 1, 1, 1, 2),
SHARED(CreateModuleContext, Operator::kNoProperties, 2, 0, 1, 1, 1, 1, 2),
#undef SHARED
diff --git a/test/unittests/compiler/js-typed-lowering-unittest.cc b/test/unittests/compiler/js-typed-lowering-unittest.cc
index 904d5f7..3a8e778 100644
--- a/test/unittests/compiler/js-typed-lowering-unittest.cc
+++ b/test/unittests/compiler/js-typed-lowering-unittest.cc
@@ -87,8 +87,9 @@
// TODO(titzer): mock the GraphReducer here for better unit testing.
GraphReducer graph_reducer(zone(), graph());
JSTypedLowering reducer(&graph_reducer, &deps_,
- JSTypedLowering::kDeoptimizationEnabled, &jsgraph,
- zone());
+ JSTypedLowering::kDeoptimizationEnabled |
+ JSTypedLowering::kTypeFeedbackEnabled,
+ &jsgraph, zone());
return reducer.Reduce(node);
}
@@ -320,8 +321,7 @@
Reduce(graph()->NewNode(javascript()->ToNumber(), input, context,
EmptyFrameState(), effect, control));
ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsToNumber(input, IsNumberConstant(BitEq(0.0)),
- graph()->start(), control));
+ EXPECT_THAT(r.replacement(), IsPlainPrimitiveToNumber(input));
}
@@ -384,8 +384,9 @@
Node* const context = UndefinedConstant();
TRACED_FOREACH(Type*, type, kJSTypes) {
Node* const lhs = Parameter(type);
- Reduction r = Reduce(
- graph()->NewNode(javascript()->StrictEqual(), lhs, the_hole, context));
+ Reduction r = Reduce(graph()->NewNode(
+ javascript()->StrictEqual(CompareOperationHints::Any()), lhs, the_hole,
+ context));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(), IsFalseConstant());
}
@@ -396,8 +397,9 @@
Node* const lhs = Parameter(Type::Unique(), 0);
Node* const rhs = Parameter(Type::Unique(), 1);
Node* const context = Parameter(Type::Any(), 2);
- Reduction r =
- Reduce(graph()->NewNode(javascript()->StrictEqual(), lhs, rhs, context));
+ Reduction r = Reduce(
+ graph()->NewNode(javascript()->StrictEqual(CompareOperationHints::Any()),
+ lhs, rhs, context));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(), IsReferenceEqual(Type::Unique(), lhs, rhs));
}
@@ -602,9 +604,9 @@
Node* context = UndefinedConstant();
Node* effect = graph()->start();
Node* control = graph()->start();
- Reduction r = Reduce(graph()->NewNode(
- javascript()->LoadProperty(feedback), base, key, vector, context,
- EmptyFrameState(), EmptyFrameState(), effect, control));
+ Reduction r = Reduce(graph()->NewNode(javascript()->LoadProperty(feedback),
+ base, key, vector, context,
+ EmptyFrameState(), effect, control));
Matcher<Node*> offset_matcher =
element_size == 1
@@ -643,9 +645,9 @@
Node* context = UndefinedConstant();
Node* effect = graph()->start();
Node* control = graph()->start();
- Reduction r = Reduce(graph()->NewNode(
- javascript()->LoadProperty(feedback), base, key, vector, context,
- EmptyFrameState(), EmptyFrameState(), effect, control));
+ Reduction r = Reduce(graph()->NewNode(javascript()->LoadProperty(feedback),
+ base, key, vector, context,
+ EmptyFrameState(), effect, control));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(
@@ -684,8 +686,7 @@
VectorSlotPair feedback;
const Operator* op = javascript()->StoreProperty(language_mode, feedback);
Node* node = graph()->NewNode(op, base, key, value, vector, context,
- EmptyFrameState(), EmptyFrameState(),
- effect, control);
+ EmptyFrameState(), effect, control);
Reduction r = Reduce(node);
Matcher<Node*> offset_matcher =
@@ -725,11 +726,14 @@
Node* context = UndefinedConstant();
Node* effect = graph()->start();
Node* control = graph()->start();
+ // TODO(mstarzinger): Once the effect-control-linearizer provides a frame
+ // state we can get rid of this checkpoint again. The reducer won't care.
+ Node* checkpoint = graph()->NewNode(common()->Checkpoint(),
+ EmptyFrameState(), effect, control);
VectorSlotPair feedback;
const Operator* op = javascript()->StoreProperty(language_mode, feedback);
Node* node = graph()->NewNode(op, base, key, value, vector, context,
- EmptyFrameState(), EmptyFrameState(),
- effect, control);
+ EmptyFrameState(), checkpoint, control);
Reduction r = Reduce(node);
Matcher<Node*> offset_matcher =
@@ -738,7 +742,7 @@
: IsWord32Shl(key, IsInt32Constant(WhichPowerOf2(element_size)));
Matcher<Node*> value_matcher =
- IsToNumber(value, context, effect, control);
+ IsToNumber(value, context, checkpoint, control);
Matcher<Node*> effect_matcher = value_matcher;
ASSERT_TRUE(r.Changed());
@@ -778,8 +782,7 @@
VectorSlotPair feedback;
const Operator* op = javascript()->StoreProperty(language_mode, feedback);
Node* node = graph()->NewNode(op, base, key, value, vector, context,
- EmptyFrameState(), EmptyFrameState(),
- effect, control);
+ EmptyFrameState(), effect, control);
Reduction r = Reduce(node);
ASSERT_TRUE(r.Changed());
@@ -805,9 +808,9 @@
Node* const context = UndefinedConstant();
Node* const effect = graph()->start();
Node* const control = graph()->start();
- Reduction const r = Reduce(graph()->NewNode(
- javascript()->LoadNamed(name, feedback), receiver, vector, context,
- EmptyFrameState(), EmptyFrameState(), effect, control));
+ Reduction const r = Reduce(
+ graph()->NewNode(javascript()->LoadNamed(name, feedback), receiver,
+ vector, context, EmptyFrameState(), effect, control));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(), IsLoadField(AccessBuilder::ForStringLength(),
receiver, effect, control));
@@ -838,6 +841,52 @@
lhs, rhs, context, frame_state0, effect, control));
}
+TEST_F(JSTypedLoweringTest, JSAddSmis) {
+ BinaryOperationHints const hints(BinaryOperationHints::kSignedSmall,
+ BinaryOperationHints::kSignedSmall,
+ BinaryOperationHints::kSignedSmall);
+ TRACED_FOREACH(LanguageMode, language_mode, kLanguageModes) {
+ Node* lhs = Parameter(Type::Number(), 0);
+ Node* rhs = Parameter(Type::Number(), 1);
+ Node* context = Parameter(Type::Any(), 2);
+ Node* frame_state0 = EmptyFrameState();
+ Node* frame_state1 = EmptyFrameState();
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Reduction r =
+ Reduce(graph()->NewNode(javascript()->Add(hints), lhs, rhs, context,
+ frame_state0, frame_state1, effect, control));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsSpeculativeNumberAdd(BinaryOperationHints::kSignedSmall, lhs,
+ rhs, effect, control));
+ }
+}
+
+// -----------------------------------------------------------------------------
+// JSSubtract
+
+TEST_F(JSTypedLoweringTest, JSSubtractSmis) {
+ BinaryOperationHints const hints(BinaryOperationHints::kSignedSmall,
+ BinaryOperationHints::kSignedSmall,
+ BinaryOperationHints::kSignedSmall);
+ TRACED_FOREACH(LanguageMode, language_mode, kLanguageModes) {
+ Node* lhs = Parameter(Type::Number(), 0);
+ Node* rhs = Parameter(Type::Number(), 1);
+ Node* context = Parameter(Type::Any(), 2);
+ Node* frame_state0 = EmptyFrameState();
+ Node* frame_state1 = EmptyFrameState();
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Reduction r = Reduce(graph()->NewNode(javascript()->Subtract(hints), lhs,
+ rhs, context, frame_state0,
+ frame_state1, effect, control));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsSpeculativeNumberSubtract(BinaryOperationHints::kSignedSmall,
+ lhs, rhs, effect, control));
+ }
+}
// -----------------------------------------------------------------------------
// JSInstanceOf
diff --git a/test/unittests/compiler/machine-operator-reducer-unittest.cc b/test/unittests/compiler/machine-operator-reducer-unittest.cc
index 8b65e04..05156ed 100644
--- a/test/unittests/compiler/machine-operator-reducer-unittest.cc
+++ b/test/unittests/compiler/machine-operator-reducer-unittest.cc
@@ -2,10 +2,11 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "src/compiler/machine-operator-reducer.h"
#include "src/base/bits.h"
#include "src/base/division-by-constant.h"
+#include "src/base/ieee754.h"
#include "src/compiler/js-graph.h"
-#include "src/compiler/machine-operator-reducer.h"
#include "src/compiler/typer.h"
#include "src/conversions-inl.h"
#include "test/unittests/compiler/graph-unittest.h"
@@ -16,6 +17,7 @@
using testing::BitEq;
using testing::Capture;
using testing::CaptureEq;
+using testing::NanSensitiveDoubleEq;
namespace v8 {
namespace internal {
@@ -848,8 +850,24 @@
// -----------------------------------------------------------------------------
-// Word32Shl
+// Word32Shr
+TEST_F(MachineOperatorReducerTest, Word32ShrWithWord32And) {
+ Node* const p0 = Parameter(0);
+ TRACED_FORRANGE(int32_t, shift, 1, 31) {
+ uint32_t mask = (1 << shift) - 1;
+ Node* node = graph()->NewNode(
+ machine()->Word32Shr(),
+ graph()->NewNode(machine()->Word32And(), p0, Int32Constant(mask)),
+ Int32Constant(shift));
+ Reduction r = Reduce(node);
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Word32Shl
TEST_F(MachineOperatorReducerTest, Word32ShlWithZeroShift) {
Node* p0 = Parameter(0);
@@ -1266,28 +1284,31 @@
TEST_F(MachineOperatorReducerTest, Int32AddWithOverflowWithZero) {
+ Node* control = graph()->start();
Node* p0 = Parameter(0);
{
Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(),
- Int32Constant(0), p0);
+ Int32Constant(0), p0, control);
- Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
+ Reduction r =
+ Reduce(graph()->NewNode(common()->Projection(1), add, control));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(), IsInt32Constant(0));
- r = Reduce(graph()->NewNode(common()->Projection(0), add));
+ r = Reduce(graph()->NewNode(common()->Projection(0), add, control));
ASSERT_TRUE(r.Changed());
EXPECT_EQ(p0, r.replacement());
}
{
Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(), p0,
- Int32Constant(0));
+ Int32Constant(0), control);
- Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
+ Reduction r =
+ Reduce(graph()->NewNode(common()->Projection(1), add, control));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(), IsInt32Constant(0));
- r = Reduce(graph()->NewNode(common()->Projection(0), add));
+ r = Reduce(graph()->NewNode(common()->Projection(0), add, control));
ASSERT_TRUE(r.Changed());
EXPECT_EQ(p0, r.replacement());
}
@@ -1295,18 +1316,20 @@
TEST_F(MachineOperatorReducerTest, Int32AddWithOverflowWithConstant) {
+ Node* control = graph()->start();
TRACED_FOREACH(int32_t, x, kInt32Values) {
TRACED_FOREACH(int32_t, y, kInt32Values) {
int32_t z;
Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(),
- Int32Constant(x), Int32Constant(y));
+ Int32Constant(x), Int32Constant(y), control);
- Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
+ Reduction r =
+ Reduce(graph()->NewNode(common()->Projection(1), add, control));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(),
IsInt32Constant(base::bits::SignedAddOverflow32(x, y, &z)));
- r = Reduce(graph()->NewNode(common()->Projection(0), add));
+ r = Reduce(graph()->NewNode(common()->Projection(0), add, control));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(), IsInt32Constant(z));
}
@@ -1319,33 +1342,36 @@
TEST_F(MachineOperatorReducerTest, Int32SubWithOverflowWithZero) {
+ Node* control = graph()->start();
Node* p0 = Parameter(0);
- Node* add =
- graph()->NewNode(machine()->Int32SubWithOverflow(), p0, Int32Constant(0));
+ Node* add = graph()->NewNode(machine()->Int32SubWithOverflow(), p0,
+ Int32Constant(0), control);
- Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
+ Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add, control));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(), IsInt32Constant(0));
- r = Reduce(graph()->NewNode(common()->Projection(0), add));
+ r = Reduce(graph()->NewNode(common()->Projection(0), add, control));
ASSERT_TRUE(r.Changed());
EXPECT_EQ(p0, r.replacement());
}
TEST_F(MachineOperatorReducerTest, Int32SubWithOverflowWithConstant) {
+ Node* control = graph()->start();
TRACED_FOREACH(int32_t, x, kInt32Values) {
TRACED_FOREACH(int32_t, y, kInt32Values) {
int32_t z;
Node* add = graph()->NewNode(machine()->Int32SubWithOverflow(),
- Int32Constant(x), Int32Constant(y));
+ Int32Constant(x), Int32Constant(y), control);
- Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
+ Reduction r =
+ Reduce(graph()->NewNode(common()->Projection(1), add, control));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(),
IsInt32Constant(base::bits::SignedSubOverflow32(x, y, &z)));
- r = Reduce(graph()->NewNode(common()->Projection(0), add));
+ r = Reduce(graph()->NewNode(common()->Projection(0), add, control));
ASSERT_TRUE(r.Changed());
EXPECT_THAT(r.replacement(), IsInt32Constant(z));
}
@@ -1399,8 +1425,133 @@
// -----------------------------------------------------------------------------
-// Float64InsertLowWord32
+// Float64Atan
+TEST_F(MachineOperatorReducerTest, Float64AtanWithConstant) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Float64Atan(), Float64Constant(x)));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsFloat64Constant(NanSensitiveDoubleEq(base::ieee754::atan(x))));
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Float64Atan2
+
+TEST_F(MachineOperatorReducerTest, Float64Atan2WithConstant) {
+ TRACED_FOREACH(double, y, kFloat64Values) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Float64Atan2(), Float64Constant(y), Float64Constant(x)));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsFloat64Constant(NanSensitiveDoubleEq(base::ieee754::atan2(y, x))));
+ }
+ }
+}
+
+TEST_F(MachineOperatorReducerTest, Float64Atan2WithNaN) {
+ Node* const p0 = Parameter(0);
+ Node* const nan = Float64Constant(std::numeric_limits<double>::quiet_NaN());
+ {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Float64Atan2(), p0, nan));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_EQ(nan, r.replacement());
+ }
+ {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Float64Atan2(), nan, p0));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_EQ(nan, r.replacement());
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Float64Cos
+
+TEST_F(MachineOperatorReducerTest, Float64CosWithConstant) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Float64Cos(), Float64Constant(x)));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsFloat64Constant(NanSensitiveDoubleEq(base::ieee754::cos(x))));
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Float64Exp
+
+TEST_F(MachineOperatorReducerTest, Float64ExpWithConstant) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Float64Exp(), Float64Constant(x)));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsFloat64Constant(NanSensitiveDoubleEq(base::ieee754::exp(x))));
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Float64Log
+
+TEST_F(MachineOperatorReducerTest, Float64LogWithConstant) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Float64Log(), Float64Constant(x)));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsFloat64Constant(NanSensitiveDoubleEq(base::ieee754::log(x))));
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Float64Log1p
+
+TEST_F(MachineOperatorReducerTest, Float64Log1pWithConstant) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Float64Log1p(), Float64Constant(x)));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsFloat64Constant(NanSensitiveDoubleEq(base::ieee754::log1p(x))));
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Float64Sin
+
+TEST_F(MachineOperatorReducerTest, Float64SinWithConstant) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Float64Sin(), Float64Constant(x)));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsFloat64Constant(NanSensitiveDoubleEq(base::ieee754::sin(x))));
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Float64Tan
+
+TEST_F(MachineOperatorReducerTest, Float64TanWithConstant) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Float64Tan(), Float64Constant(x)));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsFloat64Constant(NanSensitiveDoubleEq(base::ieee754::tan(x))));
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Float64InsertLowWord32
TEST_F(MachineOperatorReducerTest, Float64InsertLowWord32WithConstant) {
TRACED_FOREACH(double, x, kFloat64Values) {
diff --git a/test/unittests/compiler/machine-operator-unittest.cc b/test/unittests/compiler/machine-operator-unittest.cc
index 59eb484..4367705 100644
--- a/test/unittests/compiler/machine-operator-unittest.cc
+++ b/test/unittests/compiler/machine-operator-unittest.cc
@@ -208,9 +208,7 @@
PURE(Word64Ror, 2, 0, 1), // --
PURE(Word64Equal, 2, 0, 1), // --
PURE(Int32Add, 2, 0, 1), // --
- PURE(Int32AddWithOverflow, 2, 0, 2), // --
PURE(Int32Sub, 2, 0, 1), // --
- PURE(Int32SubWithOverflow, 2, 0, 2), // --
PURE(Int32Mul, 2, 0, 1), // --
PURE(Int32MulHigh, 2, 0, 1), // --
PURE(Int32Div, 2, 1, 1), // --
@@ -327,6 +325,8 @@
OPTIONAL_ENTRY(Float64RoundDown, 1, 0, 1), // --
OPTIONAL_ENTRY(Float64RoundTruncate, 1, 0, 1), // --
OPTIONAL_ENTRY(Float64RoundTiesAway, 1, 0, 1), // --
+ OPTIONAL_ENTRY(Float32Neg, 1, 0, 1), // --
+ OPTIONAL_ENTRY(Float64Neg, 1, 0, 1), // --
#undef OPTIONAL_ENTRY
};
} // namespace
diff --git a/test/unittests/compiler/move-optimizer-unittest.cc b/test/unittests/compiler/move-optimizer-unittest.cc
index 5ccd0c6..4c69384 100644
--- a/test/unittests/compiler/move-optimizer-unittest.cc
+++ b/test/unittests/compiler/move-optimizer-unittest.cc
@@ -106,11 +106,9 @@
TEST_F(MoveOptimizerTest, RemovesRedundantExplicit) {
int first_reg_index =
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(0);
+ RegisterConfiguration::Turbofan()->GetAllocatableGeneralCode(0);
int second_reg_index =
- RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
- ->GetAllocatableGeneralCode(1);
+ RegisterConfiguration::Turbofan()->GetAllocatableGeneralCode(1);
StartBlock();
auto first_instr = EmitNop();
diff --git a/test/unittests/compiler/node-test-utils.cc b/test/unittests/compiler/node-test-utils.cc
index 6adacc1..e700080 100644
--- a/test/unittests/compiler/node-test-utils.cc
+++ b/test/unittests/compiler/node-test-utils.cc
@@ -800,6 +800,40 @@
const Matcher<Node*> rhs_matcher_;
};
+class IsSpeculativeBinopMatcher final : public NodeMatcher {
+ public:
+ IsSpeculativeBinopMatcher(
+ IrOpcode::Value opcode,
+ const Matcher<BinaryOperationHints::Hint>& hint_matcher,
+ const Matcher<Node*>& lhs_matcher, const Matcher<Node*>& rhs_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher)
+ : NodeMatcher(opcode),
+ lhs_matcher_(lhs_matcher),
+ rhs_matcher_(rhs_matcher),
+ effect_matcher_(effect_matcher),
+ control_matcher_(control_matcher) {}
+
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
+ return (NodeMatcher::MatchAndExplain(node, listener) &&
+ // TODO(bmeurer): The type parameter is currently ignored.
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "lhs",
+ lhs_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1), "rhs",
+ rhs_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
+ effect_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetControlInput(node),
+ "control", control_matcher_, listener));
+ }
+
+ private:
+ const Matcher<Type*> type_matcher_;
+ const Matcher<Node*> lhs_matcher_;
+ const Matcher<Node*> rhs_matcher_;
+ const Matcher<Node*> effect_matcher_;
+ const Matcher<Node*> control_matcher_;
+};
class IsAllocateMatcher final : public NodeMatcher {
public:
@@ -2029,6 +2063,25 @@
new IsReferenceEqualMatcher(type_matcher, lhs_matcher, rhs_matcher));
}
+Matcher<Node*> IsSpeculativeNumberAdd(
+ const Matcher<BinaryOperationHints::Hint>& hint_matcher,
+ const Matcher<Node*>& lhs_matcher, const Matcher<Node*>& rhs_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher) {
+ return MakeMatcher(new IsSpeculativeBinopMatcher(
+ IrOpcode::kSpeculativeNumberAdd, hint_matcher, lhs_matcher, rhs_matcher,
+ effect_matcher, control_matcher));
+}
+
+Matcher<Node*> IsSpeculativeNumberSubtract(
+ const Matcher<BinaryOperationHints::Hint>& hint_matcher,
+ const Matcher<Node*>& lhs_matcher, const Matcher<Node*>& rhs_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher) {
+ return MakeMatcher(new IsSpeculativeBinopMatcher(
+ IrOpcode::kSpeculativeNumberSubtract, hint_matcher, lhs_matcher,
+ rhs_matcher, effect_matcher, control_matcher));
+}
Matcher<Node*> IsAllocate(const Matcher<Node*>& size_matcher,
const Matcher<Node*>& effect_matcher,
@@ -2197,6 +2250,7 @@
IS_BINOP_MATCHER(NumberShiftRight)
IS_BINOP_MATCHER(NumberShiftRightLogical)
IS_BINOP_MATCHER(NumberImul)
+IS_BINOP_MATCHER(NumberAtan2)
IS_BINOP_MATCHER(Word32And)
IS_BINOP_MATCHER(Word32Or)
IS_BINOP_MATCHER(Word32Xor)
@@ -2256,10 +2310,32 @@
IS_UNOP_MATCHER(Float64RoundTiesAway)
IS_UNOP_MATCHER(Float64ExtractLowWord32)
IS_UNOP_MATCHER(Float64ExtractHighWord32)
+IS_UNOP_MATCHER(NumberAbs)
+IS_UNOP_MATCHER(NumberAtan)
+IS_UNOP_MATCHER(NumberAtanh)
+IS_UNOP_MATCHER(NumberCeil)
+IS_UNOP_MATCHER(NumberClz32)
+IS_UNOP_MATCHER(NumberCbrt)
+IS_UNOP_MATCHER(NumberCos)
+IS_UNOP_MATCHER(NumberExp)
+IS_UNOP_MATCHER(NumberExpm1)
+IS_UNOP_MATCHER(NumberFloor)
+IS_UNOP_MATCHER(NumberFround)
+IS_UNOP_MATCHER(NumberLog)
+IS_UNOP_MATCHER(NumberLog1p)
+IS_UNOP_MATCHER(NumberLog10)
+IS_UNOP_MATCHER(NumberLog2)
+IS_UNOP_MATCHER(NumberRound)
+IS_UNOP_MATCHER(NumberSin)
+IS_UNOP_MATCHER(NumberSqrt)
+IS_UNOP_MATCHER(NumberTan)
+IS_UNOP_MATCHER(NumberTrunc)
IS_UNOP_MATCHER(NumberToInt32)
IS_UNOP_MATCHER(NumberToUint32)
+IS_UNOP_MATCHER(PlainPrimitiveToNumber)
IS_UNOP_MATCHER(ObjectIsReceiver)
IS_UNOP_MATCHER(ObjectIsSmi)
+IS_UNOP_MATCHER(StringFromCharCode)
IS_UNOP_MATCHER(Word32Clz)
IS_UNOP_MATCHER(Word32Ctz)
IS_UNOP_MATCHER(Word32Popcnt)
diff --git a/test/unittests/compiler/node-test-utils.h b/test/unittests/compiler/node-test-utils.h
index 4979bd5..60a0895 100644
--- a/test/unittests/compiler/node-test-utils.h
+++ b/test/unittests/compiler/node-test-utils.h
@@ -6,6 +6,7 @@
#define V8_UNITTESTS_COMPILER_NODE_TEST_UTILS_H_
#include "src/compiler/machine-operator.h"
+#include "src/compiler/type-hints.h"
#include "src/machine-type.h"
#include "testing/gmock/include/gmock/gmock.h"
@@ -199,6 +200,18 @@
const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsNumberLessThan(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsNumberAdd(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsSpeculativeNumberAdd(
+ const Matcher<BinaryOperationHints::Hint>& hint_matcher,
+ const Matcher<Node*>& lhs_matcher, const Matcher<Node*>& rhs_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher);
+Matcher<Node*> IsSpeculativeNumberSubtract(
+ const Matcher<BinaryOperationHints::Hint>& hint_matcher,
+ const Matcher<Node*>& lhs_matcher, const Matcher<Node*>& rhs_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher);
Matcher<Node*> IsNumberSubtract(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsNumberMultiply(const Matcher<Node*>& lhs_matcher,
@@ -211,6 +224,29 @@
const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsNumberImul(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsNumberAbs(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberAtan(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberAtan2(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsNumberAtanh(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberCeil(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberClz32(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberCos(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberExp(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberExpm1(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberFloor(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberFround(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberLog(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberLog1p(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberLog2(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberLog10(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberRound(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberCbrt(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberSin(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberSqrt(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberTan(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberTrunc(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsStringFromCharCode(const Matcher<Node*>& value_matcher);
Matcher<Node*> IsAllocate(const Matcher<Node*>& size_matcher,
const Matcher<Node*>& effect_matcher,
const Matcher<Node*>& control_matcher);
@@ -361,6 +397,7 @@
Matcher<Node*> IsParameter(const Matcher<int> index_matcher);
Matcher<Node*> IsLoadFramePointer();
Matcher<Node*> IsLoadParentFramePointer();
+Matcher<Node*> IsPlainPrimitiveToNumber(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsInt32PairAdd(const Matcher<Node*>& a_matcher,
const Matcher<Node*>& b_matcher,
diff --git a/test/unittests/compiler/register-allocator-unittest.cc b/test/unittests/compiler/register-allocator-unittest.cc
index c5ff90f..71a726f 100644
--- a/test/unittests/compiler/register-allocator-unittest.cc
+++ b/test/unittests/compiler/register-allocator-unittest.cc
@@ -678,8 +678,7 @@
Allocate();
// TODO(mtrofin): at the moment, the linear allocator spills var1 and var2,
- // so only var3 is spilled in deferred blocks. Greedy avoids spilling 1&2.
- // Expand the test once greedy is back online with this facility.
+ // so only var3 is spilled in deferred blocks.
const int var3_reg = 2;
const int var3_slot = 2;
diff --git a/test/unittests/compiler/simplified-operator-reducer-unittest.cc b/test/unittests/compiler/simplified-operator-reducer-unittest.cc
index eec39ab..f84b9bf 100644
--- a/test/unittests/compiler/simplified-operator-reducer-unittest.cc
+++ b/test/unittests/compiler/simplified-operator-reducer-unittest.cc
@@ -32,7 +32,8 @@
JSOperatorBuilder javascript(zone());
JSGraph jsgraph(isolate(), graph(), common(), &javascript, simplified(),
&machine);
- SimplifiedOperatorReducer reducer(&jsgraph);
+ GraphReducer graph_reducer(zone(), graph());
+ SimplifiedOperatorReducer reducer(&graph_reducer, &jsgraph);
return reducer.Reduce(node);
}
@@ -91,26 +92,6 @@
1866841746, 2032089723, 2147483647};
-const uint32_t kUint32Values[] = {
- 0x0, 0x5, 0x8, 0xc, 0xd, 0x26,
- 0x28, 0x29, 0x30, 0x34, 0x3e, 0x42,
- 0x50, 0x5b, 0x63, 0x71, 0x77, 0x7c,
- 0x83, 0x88, 0x96, 0x9c, 0xa3, 0xfa,
- 0x7a7, 0x165d, 0x234d, 0x3acb, 0x43a5, 0x4573,
- 0x5b4f, 0x5f14, 0x6996, 0x6c6e, 0x7289, 0x7b9a,
- 0x7bc9, 0x86bb, 0xa839, 0xaa41, 0xb03b, 0xc942,
- 0xce68, 0xcf4c, 0xd3ad, 0xdea3, 0xe90c, 0xed86,
- 0xfba5, 0x172dcc6, 0x114d8fc1, 0x182d6c9d, 0x1b1e3fad, 0x1db033bf,
- 0x1e1de755, 0x1f625c80, 0x28f6cf00, 0x2acb6a94, 0x2c20240e, 0x2f0fe54e,
- 0x31863a7c, 0x33325474, 0x3532fae3, 0x3bab82ea, 0x4c4b83a2, 0x4cd93d1e,
- 0x4f7331d4, 0x5491b09b, 0x57cc6ff9, 0x60d3b4dc, 0x653f5904, 0x690ae256,
- 0x69fe3276, 0x6bebf0ba, 0x6e2c69a3, 0x73b84ff7, 0x7b3a1924, 0x7ed032d9,
- 0x84dd734b, 0x8552ea53, 0x8680754f, 0x8e9660eb, 0x94fe2b9c, 0x972d30cf,
- 0x9b98c482, 0xb158667e, 0xb432932c, 0xb5b70989, 0xb669971a, 0xb7c359d1,
- 0xbeb15c0d, 0xc171c53d, 0xc743dd38, 0xc8e2af50, 0xc98e2df0, 0xd9d1cdf9,
- 0xdcc91049, 0xe46f396d, 0xee991950, 0xef64e521, 0xf7aeefc9, 0xffffffff};
-
-
const double kNaNs[] = {-std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::quiet_NaN(),
bit_cast<double>(V8_UINT64_C(0x7FFFFFFFFFFFFFFF)),
@@ -314,26 +295,6 @@
}
-TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToInt32WithConstant) {
- TRACED_FOREACH(double, n, kFloat64Values) {
- Reduction reduction = Reduce(graph()->NewNode(
- simplified()->ChangeTaggedToInt32(), NumberConstant(n)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsInt32Constant(DoubleToInt32(n)));
- }
-}
-
-
-TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToInt32WithNaNConstant) {
- TRACED_FOREACH(double, nan, kNaNs) {
- Reduction reduction = Reduce(graph()->NewNode(
- simplified()->ChangeTaggedToInt32(), NumberConstant(nan)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsInt32Constant(0));
- }
-}
-
-
// -----------------------------------------------------------------------------
// ChangeTaggedToUint32
@@ -360,41 +321,6 @@
}
-TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToUint32WithConstant) {
- TRACED_FOREACH(double, n, kFloat64Values) {
- Reduction reduction = Reduce(graph()->NewNode(
- simplified()->ChangeTaggedToUint32(), NumberConstant(n)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(),
- IsInt32Constant(bit_cast<int32_t>(DoubleToUint32(n))));
- }
-}
-
-
-TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToUint32WithNaNConstant) {
- TRACED_FOREACH(double, nan, kNaNs) {
- Reduction reduction = Reduce(graph()->NewNode(
- simplified()->ChangeTaggedToUint32(), NumberConstant(nan)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsInt32Constant(0));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// ChangeUint32ToTagged
-
-
-TEST_F(SimplifiedOperatorReducerTest, ChangeUint32ToTagged) {
- TRACED_FOREACH(uint32_t, n, kUint32Values) {
- Reduction reduction =
- Reduce(graph()->NewNode(simplified()->ChangeUint32ToTagged(),
- Int32Constant(bit_cast<int32_t>(n))));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(FastUI2D(n))));
- }
-}
-
// -----------------------------------------------------------------------------
// TruncateTaggedToWord32
@@ -417,6 +343,116 @@
}
}
+// -----------------------------------------------------------------------------
+// CheckTaggedPointer
+
+TEST_F(SimplifiedOperatorReducerTest, CheckTaggedPointerWithChangeBitToTagged) {
+ Node* param0 = Parameter(0);
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* value = graph()->NewNode(simplified()->ChangeBitToTagged(), param0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ simplified()->CheckTaggedPointer(), value, effect, control));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+TEST_F(SimplifiedOperatorReducerTest, CheckTaggedPointerWithHeapConstant) {
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Handle<HeapObject> kHeapObjects[] = {
+ factory()->empty_string(), factory()->null_value(),
+ factory()->species_symbol(), factory()->undefined_value()};
+ TRACED_FOREACH(Handle<HeapObject>, object, kHeapObjects) {
+ Node* value = HeapConstant(object);
+ Reduction reduction = Reduce(graph()->NewNode(
+ simplified()->CheckTaggedPointer(), value, effect, control));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CheckTaggedSigned
+
+TEST_F(SimplifiedOperatorReducerTest,
+ CheckTaggedSignedWithChangeInt31ToTaggedSigned) {
+ Node* param0 = Parameter(0);
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* value =
+ graph()->NewNode(simplified()->ChangeInt31ToTaggedSigned(), param0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ simplified()->CheckTaggedSigned(), value, effect, control));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+TEST_F(SimplifiedOperatorReducerTest, CheckTaggedSignedWithNumberConstant) {
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* value = NumberConstant(1.0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ simplified()->CheckTaggedSigned(), value, effect, control));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+// -----------------------------------------------------------------------------
+// NumberAbs
+
+TEST_F(SimplifiedOperatorReducerTest, NumberAbsWithNumberConstant) {
+ TRACED_FOREACH(double, n, kFloat64Values) {
+ Reduction reduction =
+ Reduce(graph()->NewNode(simplified()->NumberAbs(), NumberConstant(n)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsNumberConstant(std::fabs(n)));
+ }
+}
+
+// -----------------------------------------------------------------------------
+// ObjectIsSmi
+
+TEST_F(SimplifiedOperatorReducerTest, ObjectIsSmiWithChangeBitToTagged) {
+ Node* param0 = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ simplified()->ObjectIsSmi(),
+ graph()->NewNode(simplified()->ChangeBitToTagged(), param0)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsFalseConstant());
+}
+
+TEST_F(SimplifiedOperatorReducerTest,
+ ObjectIsSmiWithChangeInt31ToTaggedSigned) {
+ Node* param0 = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ simplified()->ObjectIsSmi(),
+ graph()->NewNode(simplified()->ChangeInt31ToTaggedSigned(), param0)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsTrueConstant());
+}
+
+TEST_F(SimplifiedOperatorReducerTest, ObjectIsSmiWithHeapConstant) {
+ Handle<HeapObject> kHeapObjects[] = {
+ factory()->empty_string(), factory()->null_value(),
+ factory()->species_symbol(), factory()->undefined_value()};
+ TRACED_FOREACH(Handle<HeapObject>, o, kHeapObjects) {
+ Reduction reduction =
+ Reduce(graph()->NewNode(simplified()->ObjectIsSmi(), HeapConstant(o)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsFalseConstant());
+ }
+}
+
+TEST_F(SimplifiedOperatorReducerTest, ObjectIsSmiWithNumberConstant) {
+ TRACED_FOREACH(double, n, kFloat64Values) {
+ Reduction reduction = Reduce(
+ graph()->NewNode(simplified()->ObjectIsSmi(), NumberConstant(n)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsBooleanConstant(IsSmiDouble(n)));
+ }
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
diff --git a/test/unittests/compiler/simplified-operator-unittest.cc b/test/unittests/compiler/simplified-operator-unittest.cc
index ba404a9..3343c8f 100644
--- a/test/unittests/compiler/simplified-operator-unittest.cc
+++ b/test/unittests/compiler/simplified-operator-unittest.cc
@@ -156,7 +156,8 @@
const Operator* op = simplified.LoadBuffer(access);
EXPECT_EQ(IrOpcode::kLoadBuffer, op->opcode());
- EXPECT_EQ(Operator::kNoThrow | Operator::kNoWrite, op->properties());
+ EXPECT_EQ(Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite,
+ op->properties());
EXPECT_EQ(access, BufferAccessOf(op));
EXPECT_EQ(3, op->ValueInputCount());
@@ -176,7 +177,8 @@
const Operator* op = simplified.StoreBuffer(access);
EXPECT_EQ(IrOpcode::kStoreBuffer, op->opcode());
- EXPECT_EQ(Operator::kNoRead | Operator::kNoThrow, op->properties());
+ EXPECT_EQ(Operator::kNoDeopt | Operator::kNoRead | Operator::kNoThrow,
+ op->properties());
EXPECT_EQ(access, BufferAccessOf(op));
EXPECT_EQ(4, op->ValueInputCount());
@@ -258,7 +260,8 @@
const Operator* op = simplified.LoadElement(access);
EXPECT_EQ(IrOpcode::kLoadElement, op->opcode());
- EXPECT_EQ(Operator::kNoThrow | Operator::kNoWrite, op->properties());
+ EXPECT_EQ(Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite,
+ op->properties());
EXPECT_EQ(access, ElementAccessOf(op));
EXPECT_EQ(2, op->ValueInputCount());
@@ -278,7 +281,8 @@
const Operator* op = simplified.StoreElement(access);
EXPECT_EQ(IrOpcode::kStoreElement, op->opcode());
- EXPECT_EQ(Operator::kNoRead | Operator::kNoThrow, op->properties());
+ EXPECT_EQ(Operator::kNoDeopt | Operator::kNoRead | Operator::kNoThrow,
+ op->properties());
EXPECT_EQ(access, ElementAccessOf(op));
EXPECT_EQ(3, op->ValueInputCount());
diff --git a/test/unittests/compiler/typer-unittest.cc b/test/unittests/compiler/typer-unittest.cc
index 9d664a6..61e00a5 100644
--- a/test/unittests/compiler/typer-unittest.cc
+++ b/test/unittests/compiler/typer-unittest.cc
@@ -290,44 +290,51 @@
TEST_F(TyperTest, TypeJSLessThan) {
- TestBinaryCompareOp(javascript_.LessThan(), std::less<double>());
+ TestBinaryCompareOp(javascript_.LessThan(CompareOperationHints::Any()),
+ std::less<double>());
}
TEST_F(TyperTest, TypeJSLessThanOrEqual) {
- TestBinaryCompareOp(javascript_.LessThanOrEqual(), std::less_equal<double>());
+ TestBinaryCompareOp(javascript_.LessThanOrEqual(CompareOperationHints::Any()),
+ std::less_equal<double>());
}
TEST_F(TyperTest, TypeJSGreaterThan) {
- TestBinaryCompareOp(javascript_.GreaterThan(), std::greater<double>());
+ TestBinaryCompareOp(javascript_.GreaterThan(CompareOperationHints::Any()),
+ std::greater<double>());
}
TEST_F(TyperTest, TypeJSGreaterThanOrEqual) {
- TestBinaryCompareOp(javascript_.GreaterThanOrEqual(),
- std::greater_equal<double>());
+ TestBinaryCompareOp(
+ javascript_.GreaterThanOrEqual(CompareOperationHints::Any()),
+ std::greater_equal<double>());
}
TEST_F(TyperTest, TypeJSEqual) {
- TestBinaryCompareOp(javascript_.Equal(), std::equal_to<double>());
+ TestBinaryCompareOp(javascript_.Equal(CompareOperationHints::Any()),
+ std::equal_to<double>());
}
TEST_F(TyperTest, TypeJSNotEqual) {
- TestBinaryCompareOp(javascript_.NotEqual(), std::not_equal_to<double>());
+ TestBinaryCompareOp(javascript_.NotEqual(CompareOperationHints::Any()),
+ std::not_equal_to<double>());
}
// For numbers there's no difference between strict and non-strict equality.
TEST_F(TyperTest, TypeJSStrictEqual) {
- TestBinaryCompareOp(javascript_.StrictEqual(), std::equal_to<double>());
+ TestBinaryCompareOp(javascript_.StrictEqual(CompareOperationHints::Any()),
+ std::equal_to<double>());
}
TEST_F(TyperTest, TypeJSStrictNotEqual) {
- TestBinaryCompareOp(javascript_.StrictNotEqual(),
+ TestBinaryCompareOp(javascript_.StrictNotEqual(CompareOperationHints::Any()),
std::not_equal_to<double>());
}
@@ -335,10 +342,9 @@
//------------------------------------------------------------------------------
// Monotonicity
-
-#define TEST_BINARY_MONOTONICITY(name) \
- TEST_F(TyperTest, Monotonicity_##name) { \
- TestBinaryMonotonicity(javascript_.name()); \
+#define TEST_BINARY_MONOTONICITY(name) \
+ TEST_F(TyperTest, Monotonicity_##name) { \
+ TestBinaryMonotonicity(javascript_.name(CompareOperationHints::Any())); \
}
TEST_BINARY_MONOTONICITY(Equal)
TEST_BINARY_MONOTONICITY(NotEqual)
diff --git a/test/unittests/heap/slot-set-unittest.cc b/test/unittests/heap/slot-set-unittest.cc
index 26a26f0..cfb1f1f 100644
--- a/test/unittests/heap/slot-set-unittest.cc
+++ b/test/unittests/heap/slot-set-unittest.cc
@@ -142,23 +142,29 @@
TEST(TypedSlotSet, Iterate) {
TypedSlotSet set(0);
const int kDelta = 10000001;
+ const int kHostDelta = 50001;
int added = 0;
- for (uint32_t i = 0; i < TypedSlotSet::kMaxOffset; i += kDelta) {
+ uint32_t j = 0;
+ for (uint32_t i = 0; i < TypedSlotSet::kMaxOffset;
+ i += kDelta, j += kHostDelta) {
SlotType type = static_cast<SlotType>(i % NUMBER_OF_SLOT_TYPES);
- set.Insert(type, i);
+ set.Insert(type, j, i);
++added;
}
int iterated = 0;
- set.Iterate([&iterated, kDelta](SlotType type, Address addr) {
+ set.Iterate([&iterated, kDelta, kHostDelta](SlotType type, Address host_addr,
+ Address addr) {
uint32_t i = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(addr));
+ uint32_t j = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(host_addr));
EXPECT_EQ(i % NUMBER_OF_SLOT_TYPES, static_cast<uint32_t>(type));
EXPECT_EQ(0, i % kDelta);
+ EXPECT_EQ(0, j % kHostDelta);
++iterated;
return i % 2 == 0 ? KEEP_SLOT : REMOVE_SLOT;
});
EXPECT_EQ(added, iterated);
iterated = 0;
- set.Iterate([&iterated](SlotType type, Address addr) {
+ set.Iterate([&iterated](SlotType type, Address host_addr, Address addr) {
uint32_t i = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(addr));
EXPECT_EQ(0, i % 2);
++iterated;
diff --git a/test/unittests/interpreter/bytecode-array-builder-unittest.cc b/test/unittests/interpreter/bytecode-array-builder-unittest.cc
index a569c94..7bbef45 100644
--- a/test/unittests/interpreter/bytecode-array-builder-unittest.cc
+++ b/test/unittests/interpreter/bytecode-array-builder-unittest.cc
@@ -6,6 +6,7 @@
#include "src/interpreter/bytecode-array-builder.h"
#include "src/interpreter/bytecode-array-iterator.h"
+#include "src/interpreter/bytecode-label.h"
#include "src/interpreter/bytecode-register-allocator.h"
#include "test/unittests/test-utils.h"
@@ -47,7 +48,7 @@
.LoadLiteral(factory->NewStringFromStaticChars("A constant"))
.StoreAccumulatorInRegister(reg)
.LoadUndefined()
- .StoreAccumulatorInRegister(reg)
+ .Debugger() // Prevent peephole optimization LdaNull, Star -> LdrNull.
.LoadNull()
.StoreAccumulatorInRegister(reg)
.LoadTheHole()
@@ -57,11 +58,12 @@
.LoadFalse()
.StoreAccumulatorInRegister(wide);
+ // Emit Ldar and Star taking care to foil the register optimizer.
builder.StackCheck(0)
.LoadAccumulatorWithRegister(other)
+ .BinaryOperation(Token::ADD, reg)
.StoreAccumulatorInRegister(reg)
- .LoadNull()
- .StoreAccumulatorInRegister(reg);
+ .LoadNull();
// Emit register-register transfer.
builder.MoveRegister(reg, other);
@@ -69,8 +71,8 @@
// Emit global load / store operations.
Handle<String> name = factory->NewStringFromStaticChars("var_name");
- builder.LoadGlobal(name, 1, TypeofMode::NOT_INSIDE_TYPEOF)
- .LoadGlobal(name, 1, TypeofMode::INSIDE_TYPEOF)
+ builder.LoadGlobal(1, TypeofMode::NOT_INSIDE_TYPEOF)
+ .LoadGlobal(1, TypeofMode::INSIDE_TYPEOF)
.StoreGlobal(name, 1, LanguageMode::SLOPPY)
.StoreGlobal(name, 1, LanguageMode::STRICT);
@@ -169,26 +171,34 @@
// Emit control flow. Return must be the last instruction.
BytecodeLabel start;
builder.Bind(&start);
- // Short jumps with Imm8 operands
- builder.Jump(&start)
- .JumpIfNull(&start)
- .JumpIfUndefined(&start)
- .JumpIfNotHole(&start);
+ {
+ // Short jumps with Imm8 operands
+ BytecodeLabel after_jump;
+ builder.Jump(&start)
+ .Bind(&after_jump)
+ .JumpIfNull(&start)
+ .JumpIfUndefined(&start)
+ .JumpIfNotHole(&start);
+ }
// Longer jumps with constant operands
BytecodeLabel end[8];
- builder.Jump(&end[0])
- .LoadTrue()
- .JumpIfTrue(&end[1])
- .LoadTrue()
- .JumpIfFalse(&end[2])
- .LoadLiteral(Smi::FromInt(0))
- .JumpIfTrue(&end[3])
- .LoadLiteral(Smi::FromInt(0))
- .JumpIfFalse(&end[4])
- .JumpIfNull(&end[5])
- .JumpIfUndefined(&end[6])
- .JumpIfNotHole(&end[7]);
+ {
+ BytecodeLabel after_jump;
+ builder.Jump(&end[0])
+ .Bind(&after_jump)
+ .LoadTrue()
+ .JumpIfTrue(&end[1])
+ .LoadTrue()
+ .JumpIfFalse(&end[2])
+ .LoadLiteral(Smi::FromInt(0))
+ .JumpIfTrue(&end[3])
+ .LoadLiteral(Smi::FromInt(0))
+ .JumpIfFalse(&end[4])
+ .JumpIfNull(&end[5])
+ .JumpIfUndefined(&end[6])
+ .JumpIfNotHole(&end[7]);
+ }
// Perform an operation that returns boolean value to
// generate JumpIfTrue/False
@@ -207,20 +217,26 @@
builder.LoadTrue();
}
// Longer jumps requiring Constant operand
- builder.Jump(&start).JumpIfNull(&start).JumpIfUndefined(&start).JumpIfNotHole(
- &start);
- // Perform an operation that returns boolean value to
- // generate JumpIfTrue/False
- builder.CompareOperation(Token::Value::EQ, reg)
- .JumpIfTrue(&start)
- .CompareOperation(Token::Value::EQ, reg)
- .JumpIfFalse(&start);
- // Perform an operation that returns a non-boolean operation to
- // generate JumpIfToBooleanTrue/False.
- builder.BinaryOperation(Token::Value::ADD, reg)
- .JumpIfTrue(&start)
- .BinaryOperation(Token::Value::ADD, reg)
- .JumpIfFalse(&start);
+ {
+ BytecodeLabel after_jump;
+ builder.Jump(&start)
+ .Bind(&after_jump)
+ .JumpIfNull(&start)
+ .JumpIfUndefined(&start)
+ .JumpIfNotHole(&start);
+ // Perform an operation that returns boolean value to
+ // generate JumpIfTrue/False
+ builder.CompareOperation(Token::Value::EQ, reg)
+ .JumpIfTrue(&start)
+ .CompareOperation(Token::Value::EQ, reg)
+ .JumpIfFalse(&start);
+ // Perform an operation that returns a non-boolean operation to
+ // generate JumpIfToBooleanTrue/False.
+ builder.BinaryOperation(Token::Value::ADD, reg)
+ .JumpIfTrue(&start)
+ .BinaryOperation(Token::Value::ADD, reg)
+ .JumpIfFalse(&start);
+ }
// Emit stack check bytecode.
builder.StackCheck(0);
@@ -228,9 +244,9 @@
// Emit throw and re-throw in it's own basic block so that the rest of the
// code isn't omitted due to being dead.
BytecodeLabel after_throw;
- builder.Jump(&after_throw).Throw().Bind(&after_throw);
+ builder.Throw().Bind(&after_throw);
BytecodeLabel after_rethrow;
- builder.Jump(&after_rethrow).ReThrow().Bind(&after_rethrow);
+ builder.ReThrow().Bind(&after_rethrow);
builder.ForInPrepare(reg)
.ForInDone(reg, reg)
@@ -250,14 +266,14 @@
Handle<String> wide_name = factory->NewStringFromStaticChars("var_wide_name");
// Emit wide global load / store operations.
- builder.LoadGlobal(name, 1024, TypeofMode::NOT_INSIDE_TYPEOF)
- .LoadGlobal(name, 1024, TypeofMode::INSIDE_TYPEOF)
- .LoadGlobal(name, 1024, TypeofMode::INSIDE_TYPEOF)
+ builder.LoadGlobal(1024, TypeofMode::NOT_INSIDE_TYPEOF)
+ .LoadGlobal(1024, TypeofMode::INSIDE_TYPEOF)
+ .LoadGlobal(1024, TypeofMode::INSIDE_TYPEOF)
.StoreGlobal(name, 1024, LanguageMode::SLOPPY)
.StoreGlobal(wide_name, 1, LanguageMode::STRICT);
// Emit extra wide global load.
- builder.LoadGlobal(name, 1024 * 1024, TypeofMode::NOT_INSIDE_TYPEOF);
+ builder.LoadGlobal(1024 * 1024, TypeofMode::NOT_INSIDE_TYPEOF);
// Emit wide load / store property operations.
builder.LoadNamedProperty(reg, wide_name, 0)
@@ -276,6 +292,19 @@
.StoreLookupSlot(wide_name, LanguageMode::SLOPPY)
.StoreLookupSlot(wide_name, LanguageMode::STRICT);
+ // Emit loads which will be transformed to Ldr equivalents by the peephole
+ // optimizer.
+ builder.LoadNamedProperty(reg, name, 0)
+ .StoreAccumulatorInRegister(reg)
+ .LoadKeyedProperty(reg, 0)
+ .StoreAccumulatorInRegister(reg)
+ .LoadContextSlot(reg, 1)
+ .StoreAccumulatorInRegister(reg)
+ .LoadGlobal(0, TypeofMode::NOT_INSIDE_TYPEOF)
+ .StoreAccumulatorInRegister(reg)
+ .LoadUndefined()
+ .StoreAccumulatorInRegister(reg);
+
// CreateClosureWide
Handle<SharedFunctionInfo> shared_info2 = factory->NewSharedFunctionInfo(
factory->NewStringFromStaticChars("function_b"), MaybeHandle<Code>(),
@@ -289,14 +318,22 @@
.CreateObjectLiteral(factory->NewFixedArray(2), 0, 0);
// Longer jumps requiring ConstantWide operand
- builder.Jump(&start).JumpIfNull(&start).JumpIfUndefined(&start).JumpIfNotHole(
- &start);
+ {
+ BytecodeLabel after_jump;
+ builder.Jump(&start)
+ .Bind(&after_jump)
+ .JumpIfNull(&start)
+ .JumpIfUndefined(&start)
+ .JumpIfNotHole(&start);
+ }
+
// Perform an operation that returns boolean value to
// generate JumpIfTrue/False
builder.CompareOperation(Token::Value::EQ, reg)
.JumpIfTrue(&start)
.CompareOperation(Token::Value::EQ, reg)
.JumpIfFalse(&start);
+
// Perform an operation that returns a non-boolean operation to
// generate JumpIfToBooleanTrue/False.
builder.BinaryOperation(Token::Value::ADD, reg)
@@ -349,6 +386,21 @@
// Insert entry for nop bytecode as this often gets optimized out.
scorecard[Bytecodes::ToByte(Bytecode::kNop)] = 1;
+ if (!FLAG_ignition_peephole) {
+ // Insert entries for bytecodes only emitted by peephole optimizer.
+ scorecard[Bytecodes::ToByte(Bytecode::kLdrNamedProperty)] = 1;
+ scorecard[Bytecodes::ToByte(Bytecode::kLdrKeyedProperty)] = 1;
+ scorecard[Bytecodes::ToByte(Bytecode::kLdrGlobal)] = 1;
+ scorecard[Bytecodes::ToByte(Bytecode::kLdrContextSlot)] = 1;
+ scorecard[Bytecodes::ToByte(Bytecode::kLdrUndefined)] = 1;
+ scorecard[Bytecodes::ToByte(Bytecode::kLogicalNot)] = 1;
+ scorecard[Bytecodes::ToByte(Bytecode::kJump)] = 1;
+ scorecard[Bytecodes::ToByte(Bytecode::kJumpIfTrue)] = 1;
+ scorecard[Bytecodes::ToByte(Bytecode::kJumpIfFalse)] = 1;
+ scorecard[Bytecodes::ToByte(Bytecode::kJumpIfTrueConstant)] = 1;
+ scorecard[Bytecodes::ToByte(Bytecode::kJumpIfFalseConstant)] = 1;
+ }
+
// Check return occurs at the end and only once in the BytecodeArray.
CHECK_EQ(final_bytecode, Bytecode::kReturn);
CHECK_EQ(scorecard[Bytecodes::ToByte(final_bytecode)], 1);
@@ -370,9 +422,20 @@
BytecodeArrayBuilder builder(isolate(), zone(), 0, contexts, locals);
BytecodeRegisterAllocator temporaries(
zone(), builder.temporary_register_allocator());
+ for (int i = 0; i < locals + contexts; i++) {
+ builder.LoadLiteral(Smi::FromInt(0));
+ builder.StoreAccumulatorInRegister(Register(i));
+ }
for (int i = 0; i < temps; i++) {
+ builder.LoadLiteral(Smi::FromInt(0));
builder.StoreAccumulatorInRegister(temporaries.NewRegister());
}
+ if (temps > 0) {
+ // Ensure temporaries are used so not optimized away by the
+ // register optimizer.
+ builder.New(Register(locals + contexts), Register(locals + contexts),
+ static_cast<size_t>(temps));
+ }
builder.Return();
Handle<BytecodeArray> the_array = builder.ToBytecodeArray();
@@ -398,6 +461,7 @@
TEST_F(BytecodeArrayBuilderTest, Parameters) {
BytecodeArrayBuilder builder(isolate(), zone(), 10, 0, 0);
+
Register param0(builder.Parameter(0));
Register param9(builder.Parameter(9));
CHECK_EQ(param9.index() - param0.index(), 9);
@@ -429,6 +493,7 @@
TEST_F(BytecodeArrayBuilderTest, Constants) {
BytecodeArrayBuilder builder(isolate(), zone(), 0, 0, 0);
+
Factory* factory = isolate()->factory();
Handle<HeapObject> heap_num_1 = factory->NewHeapNumber(3.14);
Handle<HeapObject> heap_num_2 = factory->NewHeapNumber(5.2);
@@ -447,16 +512,24 @@
CHECK_EQ(array->constant_pool()->length(), 3);
}
+static Bytecode PeepholeToBoolean(Bytecode jump_bytecode) {
+ return FLAG_ignition_peephole
+ ? Bytecodes::GetJumpWithoutToBoolean(jump_bytecode)
+ : jump_bytecode;
+}
TEST_F(BytecodeArrayBuilderTest, ForwardJumps) {
static const int kFarJumpDistance = 256;
BytecodeArrayBuilder builder(isolate(), zone(), 0, 0, 1);
+
Register reg(0);
BytecodeLabel far0, far1, far2, far3, far4;
BytecodeLabel near0, near1, near2, near3, near4;
+ BytecodeLabel after_jump0, after_jump1;
builder.Jump(&near0)
+ .Bind(&after_jump0)
.CompareOperation(Token::Value::EQ, reg)
.JumpIfTrue(&near1)
.CompareOperation(Token::Value::EQ, reg)
@@ -471,6 +544,7 @@
.Bind(&near3)
.Bind(&near4)
.Jump(&far0)
+ .Bind(&after_jump1)
.CompareOperation(Token::Value::EQ, reg)
.JumpIfTrue(&far1)
.CompareOperation(Token::Value::EQ, reg)
@@ -496,14 +570,16 @@
// Ignore compare operation.
iterator.Advance();
- CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrue);
+ CHECK_EQ(iterator.current_bytecode(),
+ PeepholeToBoolean(Bytecode::kJumpIfToBooleanTrue));
CHECK_EQ(iterator.GetImmediateOperand(0), 14);
iterator.Advance();
// Ignore compare operation.
iterator.Advance();
- CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalse);
+ CHECK_EQ(iterator.current_bytecode(),
+ PeepholeToBoolean(Bytecode::kJumpIfToBooleanFalse));
CHECK_EQ(iterator.GetImmediateOperand(0), 10);
iterator.Advance();
@@ -529,7 +605,8 @@
// Ignore compare operation.
iterator.Advance();
- CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrueConstant);
+ CHECK_EQ(iterator.current_bytecode(),
+ PeepholeToBoolean(Bytecode::kJumpIfToBooleanTrueConstant));
CHECK_EQ(*iterator.GetConstantForIndexOperand(0),
Smi::FromInt(kFarJumpDistance - 4));
iterator.Advance();
@@ -537,7 +614,8 @@
// Ignore compare operation.
iterator.Advance();
- CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalseConstant);
+ CHECK_EQ(iterator.current_bytecode(),
+ PeepholeToBoolean(Bytecode::kJumpIfToBooleanFalseConstant));
CHECK_EQ(*iterator.GetConstantForIndexOperand(0),
Smi::FromInt(kFarJumpDistance - 8));
iterator.Advance();
@@ -563,6 +641,7 @@
TEST_F(BytecodeArrayBuilderTest, BackwardJumps) {
BytecodeArrayBuilder builder(isolate(), zone(), 0, 0, 1);
+
Register reg(0);
BytecodeLabel label0, label1, label2, label3, label4;
@@ -581,7 +660,8 @@
.BinaryOperation(Token::Value::ADD, reg)
.JumpIfFalse(&label4);
for (int i = 0; i < 63; i++) {
- builder.Jump(&label4);
+ BytecodeLabel after_jump;
+ builder.Jump(&label4).Bind(&after_jump);
}
// Add padding to force wide backwards jumps.
@@ -594,6 +674,8 @@
builder.CompareOperation(Token::Value::EQ, reg).JumpIfFalse(&label2);
builder.CompareOperation(Token::Value::EQ, reg).JumpIfTrue(&label1);
builder.Jump(&label0);
+ BytecodeLabel end;
+ builder.Bind(&end);
builder.Return();
Handle<BytecodeArray> array = builder.ToBytecodeArray();
@@ -603,13 +685,15 @@
iterator.Advance();
// Ignore compare operation.
iterator.Advance();
- CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrue);
+ CHECK_EQ(iterator.current_bytecode(),
+ PeepholeToBoolean(Bytecode::kJumpIfToBooleanTrue));
CHECK_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
CHECK_EQ(iterator.GetImmediateOperand(0), -2);
iterator.Advance();
// Ignore compare operation.
iterator.Advance();
- CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalse);
+ CHECK_EQ(iterator.current_bytecode(),
+ PeepholeToBoolean(Bytecode::kJumpIfToBooleanFalse));
CHECK_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
CHECK_EQ(iterator.GetImmediateOperand(0), -2);
iterator.Advance();
@@ -650,13 +734,15 @@
iterator.Advance();
// Ignore compare operation.
iterator.Advance();
- CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalse);
+ CHECK_EQ(iterator.current_bytecode(),
+ PeepholeToBoolean(Bytecode::kJumpIfToBooleanFalse));
CHECK_EQ(iterator.current_operand_scale(), OperandScale::kDouble);
CHECK_EQ(iterator.GetImmediateOperand(0), -409);
iterator.Advance();
// Ignore compare operation.
iterator.Advance();
- CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrue);
+ CHECK_EQ(iterator.current_bytecode(),
+ PeepholeToBoolean(Bytecode::kJumpIfToBooleanTrue));
CHECK_EQ(iterator.current_operand_scale(), OperandScale::kDouble);
CHECK_EQ(iterator.GetImmediateOperand(0), -419);
iterator.Advance();
@@ -675,9 +761,15 @@
// Labels can only have 1 forward reference, but
// can be referred to mulitple times once bound.
- BytecodeLabel label;
+ BytecodeLabel label, after_jump0, after_jump1;
- builder.Jump(&label).Bind(&label).Jump(&label).Jump(&label).Return();
+ builder.Jump(&label)
+ .Bind(&label)
+ .Jump(&label)
+ .Bind(&after_jump0)
+ .Jump(&label)
+ .Bind(&after_jump1)
+ .Return();
Handle<BytecodeArray> array = builder.ToBytecodeArray();
BytecodeArrayIterator iterator(array);
@@ -701,8 +793,13 @@
BytecodeArrayBuilder builder(isolate(), zone(), 0, 0, 0);
for (int i = 0; i < kRepeats; i++) {
- BytecodeLabel label;
- builder.Jump(&label).Bind(&label).Jump(&label).Jump(&label);
+ BytecodeLabel label, after_jump0, after_jump1;
+ builder.Jump(&label)
+ .Bind(&label)
+ .Jump(&label)
+ .Bind(&after_jump0)
+ .Jump(&label)
+ .Bind(&after_jump1);
}
builder.Return();
diff --git a/test/unittests/interpreter/bytecode-array-iterator-unittest.cc b/test/unittests/interpreter/bytecode-array-iterator-unittest.cc
index aa9effe..6b7374e 100644
--- a/test/unittests/interpreter/bytecode-array-iterator-unittest.cc
+++ b/test/unittests/interpreter/bytecode-array-iterator-unittest.cc
@@ -47,14 +47,16 @@
.LoadLiteral(smi_1)
.StoreAccumulatorInRegister(reg_1)
.LoadAccumulatorWithRegister(reg_0)
+ .BinaryOperation(Token::Value::ADD, reg_0)
.StoreAccumulatorInRegister(reg_1)
.LoadNamedProperty(reg_1, name, feedback_slot)
+ .BinaryOperation(Token::Value::ADD, reg_0)
.StoreAccumulatorInRegister(param)
.CallRuntimeForPair(Runtime::kLoadLookupSlotForCall, param, 1, reg_0)
.ForInPrepare(reg_0)
.CallRuntime(Runtime::kLoadIC_Miss, reg_0, 1)
.Debugger()
- .LoadGlobal(name, 0x10000000, TypeofMode::NOT_INSIDE_TYPEOF)
+ .LoadGlobal(0x10000000, TypeofMode::NOT_INSIDE_TYPEOF)
.Return();
// Test iterator sees the expected output from the builder.
@@ -155,6 +157,15 @@
offset += Bytecodes::Size(Bytecode::kLdar, OperandScale::kSingle);
iterator.Advance();
+ CHECK_EQ(iterator.current_bytecode(), Bytecode::kAdd);
+ CHECK_EQ(iterator.current_offset(), offset);
+ CHECK_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
+ CHECK_EQ(iterator.GetRegisterOperand(0).index(), reg_0.index());
+ CHECK_EQ(iterator.GetRegisterOperandRange(0), 1);
+ CHECK(!iterator.done());
+ offset += Bytecodes::Size(Bytecode::kStar, OperandScale::kSingle);
+ iterator.Advance();
+
CHECK_EQ(iterator.current_bytecode(), Bytecode::kStar);
CHECK_EQ(iterator.current_offset(), offset);
CHECK_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
@@ -164,14 +175,23 @@
offset += Bytecodes::Size(Bytecode::kStar, OperandScale::kSingle);
iterator.Advance();
- CHECK_EQ(iterator.current_bytecode(), Bytecode::kLoadIC);
+ CHECK_EQ(iterator.current_bytecode(), Bytecode::kLdaNamedProperty);
CHECK_EQ(iterator.current_offset(), offset);
CHECK_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
CHECK_EQ(iterator.GetRegisterOperand(0).index(), reg_1.index());
CHECK_EQ(iterator.GetIndexOperand(1), name_index);
CHECK_EQ(iterator.GetIndexOperand(2), feedback_slot);
CHECK(!iterator.done());
- offset += Bytecodes::Size(Bytecode::kLoadIC, OperandScale::kSingle);
+ offset += Bytecodes::Size(Bytecode::kLdaNamedProperty, OperandScale::kSingle);
+ iterator.Advance();
+
+ CHECK_EQ(iterator.current_bytecode(), Bytecode::kAdd);
+ CHECK_EQ(iterator.current_offset(), offset);
+ CHECK_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
+ CHECK_EQ(iterator.GetRegisterOperand(0).index(), reg_0.index());
+ CHECK_EQ(iterator.GetRegisterOperandRange(0), 1);
+ CHECK(!iterator.done());
+ offset += Bytecodes::Size(Bytecode::kStar, OperandScale::kSingle);
iterator.Advance();
CHECK_EQ(iterator.current_bytecode(), Bytecode::kStar);
@@ -209,8 +229,7 @@
CHECK_EQ(iterator.current_bytecode(), Bytecode::kCallRuntime);
CHECK_EQ(iterator.current_offset(), offset);
CHECK_EQ(iterator.current_operand_scale(), OperandScale::kSingle);
- CHECK_EQ(static_cast<Runtime::FunctionId>(iterator.GetRuntimeIdOperand(0)),
- Runtime::kLoadIC_Miss);
+ CHECK_EQ(iterator.GetRuntimeIdOperand(0), Runtime::kLoadIC_Miss);
CHECK_EQ(iterator.GetRegisterOperand(1).index(), reg_0.index());
CHECK_EQ(iterator.GetRegisterCountOperand(2), 1);
CHECK(!iterator.done());
@@ -227,8 +246,8 @@
CHECK_EQ(iterator.current_bytecode(), Bytecode::kLdaGlobal);
CHECK_EQ(iterator.current_offset(), offset);
CHECK_EQ(iterator.current_operand_scale(), OperandScale::kQuadruple);
- CHECK_EQ(iterator.current_bytecode_size(), 10);
- CHECK_EQ(iterator.GetIndexOperand(1), 0x10000000);
+ CHECK_EQ(iterator.current_bytecode_size(), 6);
+ CHECK_EQ(iterator.GetIndexOperand(0), 0x10000000);
offset += Bytecodes::Size(Bytecode::kLdaGlobal, OperandScale::kQuadruple) +
kPrefixByteSize;
iterator.Advance();
diff --git a/test/unittests/interpreter/bytecode-array-writer-unittest.cc b/test/unittests/interpreter/bytecode-array-writer-unittest.cc
index a1b4910..90a91ce 100644
--- a/test/unittests/interpreter/bytecode-array-writer-unittest.cc
+++ b/test/unittests/interpreter/bytecode-array-writer-unittest.cc
@@ -4,7 +4,11 @@
#include "src/v8.h"
+#include "src/api.h"
+#include "src/factory.h"
#include "src/interpreter/bytecode-array-writer.h"
+#include "src/interpreter/bytecode-label.h"
+#include "src/interpreter/constant-array-builder.h"
#include "src/interpreter/source-position-table.h"
#include "src/isolate.h"
#include "src/utils.h"
@@ -18,39 +22,45 @@
class BytecodeArrayWriterUnittest : public TestWithIsolateAndZone {
public:
BytecodeArrayWriterUnittest()
- : source_position_builder_(isolate(), zone()),
- bytecode_array_writer_(zone(), &source_position_builder_) {}
+ : constant_array_builder_(isolate(), zone()),
+ bytecode_array_writer_(isolate(), zone(), &constant_array_builder_) {}
~BytecodeArrayWriterUnittest() override {}
void Write(BytecodeNode* node, const BytecodeSourceInfo& info);
void Write(Bytecode bytecode,
const BytecodeSourceInfo& info = BytecodeSourceInfo());
- void Write(Bytecode bytecode, uint32_t operand0, OperandScale operand_scale,
+ void Write(Bytecode bytecode, uint32_t operand0,
const BytecodeSourceInfo& info = BytecodeSourceInfo());
void Write(Bytecode bytecode, uint32_t operand0, uint32_t operand1,
- OperandScale operand_scale,
+
const BytecodeSourceInfo& info = BytecodeSourceInfo());
void Write(Bytecode bytecode, uint32_t operand0, uint32_t operand1,
- uint32_t operand2, OperandScale operand_scale,
+ uint32_t operand2,
const BytecodeSourceInfo& info = BytecodeSourceInfo());
void Write(Bytecode bytecode, uint32_t operand0, uint32_t operand1,
- uint32_t operand2, uint32_t operand3, OperandScale operand_scale,
+ uint32_t operand2, uint32_t operand3,
const BytecodeSourceInfo& info = BytecodeSourceInfo());
- SourcePositionTableBuilder* source_position_builder() {
- return &source_position_builder_;
- }
+ void WriteJump(Bytecode bytecode, BytecodeLabel* label,
+
+ const BytecodeSourceInfo& info = BytecodeSourceInfo());
+
BytecodeArrayWriter* writer() { return &bytecode_array_writer_; }
+ ZoneVector<unsigned char>* bytecodes() { return writer()->bytecodes(); }
+ SourcePositionTableBuilder* source_position_table_builder() {
+ return writer()->source_position_table_builder();
+ }
+ int max_register_count() { return writer()->max_register_count(); }
private:
- SourcePositionTableBuilder source_position_builder_;
+ ConstantArrayBuilder constant_array_builder_;
BytecodeArrayWriter bytecode_array_writer_;
};
void BytecodeArrayWriterUnittest::Write(BytecodeNode* node,
const BytecodeSourceInfo& info) {
if (info.is_valid()) {
- node->source_info().Update(info);
+ node->source_info().Clone(info);
}
writer()->Write(node);
}
@@ -62,72 +72,76 @@
}
void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0,
- OperandScale operand_scale,
const BytecodeSourceInfo& info) {
- BytecodeNode node(bytecode, operand0, operand_scale);
+ BytecodeNode node(bytecode, operand0);
Write(&node, info);
}
void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0,
uint32_t operand1,
- OperandScale operand_scale,
const BytecodeSourceInfo& info) {
- BytecodeNode node(bytecode, operand0, operand1, operand_scale);
+ BytecodeNode node(bytecode, operand0, operand1);
Write(&node, info);
}
void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0,
uint32_t operand1, uint32_t operand2,
- OperandScale operand_scale,
const BytecodeSourceInfo& info) {
- BytecodeNode node(bytecode, operand0, operand1, operand2, operand_scale);
+ BytecodeNode node(bytecode, operand0, operand1, operand2);
Write(&node, info);
}
void BytecodeArrayWriterUnittest::Write(Bytecode bytecode, uint32_t operand0,
uint32_t operand1, uint32_t operand2,
uint32_t operand3,
- OperandScale operand_scale,
const BytecodeSourceInfo& info) {
- BytecodeNode node(bytecode, operand0, operand1, operand2, operand3,
- operand_scale);
+ BytecodeNode node(bytecode, operand0, operand1, operand2, operand3);
Write(&node, info);
}
+void BytecodeArrayWriterUnittest::WriteJump(Bytecode bytecode,
+ BytecodeLabel* label,
+ const BytecodeSourceInfo& info) {
+ BytecodeNode node(bytecode, 0);
+ if (info.is_valid()) {
+ node.source_info().Clone(info);
+ }
+ writer()->WriteJump(&node, label);
+}
+
TEST_F(BytecodeArrayWriterUnittest, SimpleExample) {
- CHECK_EQ(writer()->bytecodes()->size(), 0);
+ CHECK_EQ(bytecodes()->size(), 0);
Write(Bytecode::kStackCheck, {10, false});
- CHECK_EQ(writer()->bytecodes()->size(), 1);
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 0);
+ CHECK_EQ(bytecodes()->size(), 1);
+ CHECK_EQ(max_register_count(), 0);
- Write(Bytecode::kLdaSmi, 0xff, OperandScale::kSingle, {55, true});
- CHECK_EQ(writer()->bytecodes()->size(), 3);
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 0);
+ Write(Bytecode::kLdaSmi, 127, {55, true});
+ CHECK_EQ(bytecodes()->size(), 3);
+ CHECK_EQ(max_register_count(), 0);
- Write(Bytecode::kLdar, Register(1).ToOperand(), OperandScale::kDouble);
- CHECK_EQ(writer()->bytecodes()->size(), 7);
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 2 * kPointerSize);
+ Write(Bytecode::kLdar, Register(200).ToOperand());
+ CHECK_EQ(bytecodes()->size(), 7);
+ CHECK_EQ(max_register_count(), 201);
Write(Bytecode::kReturn, {70, true});
- CHECK_EQ(writer()->bytecodes()->size(), 8);
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 2 * kPointerSize);
+ CHECK_EQ(bytecodes()->size(), 8);
+ CHECK_EQ(max_register_count(), 201);
- static const uint8_t bytes[] = {B(StackCheck), B(LdaSmi), U8(0xff), B(Wide),
- B(Ldar), R16(1), B(Return)};
- CHECK_EQ(writer()->bytecodes()->size(), arraysize(bytes));
+ static const uint8_t bytes[] = {B(StackCheck), B(LdaSmi), U8(127), B(Wide),
+ B(Ldar), R16(200), B(Return)};
+ CHECK_EQ(bytecodes()->size(), arraysize(bytes));
for (size_t i = 0; i < arraysize(bytes); ++i) {
- CHECK_EQ(writer()->bytecodes()->at(i), bytes[i]);
+ CHECK_EQ(bytecodes()->at(i), bytes[i]);
}
- CHECK_EQ(writer()->FlushForOffset(), arraysize(bytes));
- writer()->FlushBasicBlock();
- CHECK_EQ(writer()->bytecodes()->size(), arraysize(bytes));
+ writer()->ToBytecodeArray(0, 0, factory()->empty_fixed_array());
+ CHECK_EQ(bytecodes()->size(), arraysize(bytes));
PositionTableEntry expected_positions[] = {
{0, 10, false}, {1, 55, true}, {7, 70, true}};
Handle<ByteArray> source_positions =
- source_position_builder()->ToSourcePositionTable();
+ source_position_table_builder()->ToSourcePositionTable();
SourcePositionTableIterator source_iterator(*source_positions);
for (size_t i = 0; i < arraysize(expected_positions); ++i) {
const PositionTableEntry& expected = expected_positions[i];
@@ -173,50 +187,57 @@
{0, 30, false}, {1, 42, true}, {3, 42, false}, {5, 68, true},
{17, 63, true}, {31, 54, false}, {36, 85, true}, {44, 85, true}};
+ BytecodeLabel back_jump, jump_for_in, jump_end_1, jump_end_2, jump_end_3;
+
#define R(i) static_cast<uint32_t>(Register(i).ToOperand())
Write(Bytecode::kStackCheck, {30, false});
- Write(Bytecode::kLdaConstant, U8(0), OperandScale::kSingle, {42, true});
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 0 * kPointerSize);
- Write(Bytecode::kStar, R(1), OperandScale::kSingle, {42, false});
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 2 * kPointerSize);
- Write(Bytecode::kJumpIfUndefined, U8(38), OperandScale::kSingle, {68, true});
- Write(Bytecode::kJumpIfNull, U8(36), OperandScale::kSingle);
+ Write(Bytecode::kLdaConstant, U8(0), {42, true});
+ CHECK_EQ(max_register_count(), 0);
+ Write(Bytecode::kStar, R(1), {42, false});
+ CHECK_EQ(max_register_count(), 2);
+ WriteJump(Bytecode::kJumpIfUndefined, &jump_end_1, {68, true});
+ WriteJump(Bytecode::kJumpIfNull, &jump_end_2);
Write(Bytecode::kToObject);
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 2 * kPointerSize);
- Write(Bytecode::kStar, R(3), OperandScale::kSingle);
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 4 * kPointerSize);
- Write(Bytecode::kForInPrepare, R(4), OperandScale::kSingle);
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 7 * kPointerSize);
+ CHECK_EQ(max_register_count(), 2);
+ Write(Bytecode::kStar, R(3));
+ CHECK_EQ(max_register_count(), 4);
+ Write(Bytecode::kForInPrepare, R(4));
+ CHECK_EQ(max_register_count(), 7);
Write(Bytecode::kLdaZero);
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 7 * kPointerSize);
- Write(Bytecode::kStar, R(7), OperandScale::kSingle);
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 8 * kPointerSize);
- Write(Bytecode::kForInDone, R(7), R(6), OperandScale::kSingle, {63, true});
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 8 * kPointerSize);
- Write(Bytecode::kJumpIfTrue, U8(23), OperandScale::kSingle);
- Write(Bytecode::kForInNext, R(3), R(7), R(4), U8(1), OperandScale::kSingle);
- Write(Bytecode::kJumpIfUndefined, U8(10), OperandScale::kSingle);
- Write(Bytecode::kStar, R(0), OperandScale::kSingle);
+ CHECK_EQ(max_register_count(), 7);
+ Write(Bytecode::kStar, R(7));
+ CHECK_EQ(max_register_count(), 8);
+ writer()->BindLabel(&back_jump);
+ Write(Bytecode::kForInDone, R(7), R(6), {63, true});
+ CHECK_EQ(max_register_count(), 8);
+ WriteJump(Bytecode::kJumpIfTrue, &jump_end_3);
+ Write(Bytecode::kForInNext, R(3), R(7), R(4), U8(1));
+ WriteJump(Bytecode::kJumpIfUndefined, &jump_for_in);
+ Write(Bytecode::kStar, R(0));
Write(Bytecode::kStackCheck, {54, false});
- Write(Bytecode::kLdar, R(0), OperandScale::kSingle);
- Write(Bytecode::kStar, R(2), OperandScale::kSingle);
+ Write(Bytecode::kLdar, R(0));
+ Write(Bytecode::kStar, R(2));
Write(Bytecode::kReturn, {85, true});
- Write(Bytecode::kForInStep, R(7), OperandScale::kSingle);
- Write(Bytecode::kStar, R(7), OperandScale::kSingle);
- Write(Bytecode::kJump, U8(-24), OperandScale::kSingle);
+ writer()->BindLabel(&jump_for_in);
+ Write(Bytecode::kForInStep, R(7));
+ Write(Bytecode::kStar, R(7));
+ WriteJump(Bytecode::kJump, &back_jump);
+ writer()->BindLabel(&jump_end_1);
+ writer()->BindLabel(&jump_end_2);
+ writer()->BindLabel(&jump_end_3);
Write(Bytecode::kLdaUndefined);
Write(Bytecode::kReturn, {85, true});
- CHECK_EQ(writer()->GetMaximumFrameSizeUsed(), 8 * kPointerSize);
+ CHECK_EQ(max_register_count(), 8);
#undef R
- CHECK_EQ(writer()->bytecodes()->size(), arraysize(expected_bytes));
+ CHECK_EQ(bytecodes()->size(), arraysize(expected_bytes));
for (size_t i = 0; i < arraysize(expected_bytes); ++i) {
- CHECK_EQ(static_cast<int>(writer()->bytecodes()->at(i)),
+ CHECK_EQ(static_cast<int>(bytecodes()->at(i)),
static_cast<int>(expected_bytes[i]));
}
Handle<ByteArray> source_positions =
- source_position_builder()->ToSourcePositionTable();
+ source_position_table_builder()->ToSourcePositionTable();
SourcePositionTableIterator source_iterator(*source_positions);
for (size_t i = 0; i < arraysize(expected_positions); ++i) {
const PositionTableEntry& expected = expected_positions[i];
diff --git a/test/unittests/interpreter/bytecode-dead-code-optimizer-unittest.cc b/test/unittests/interpreter/bytecode-dead-code-optimizer-unittest.cc
new file mode 100644
index 0000000..915c23d
--- /dev/null
+++ b/test/unittests/interpreter/bytecode-dead-code-optimizer-unittest.cc
@@ -0,0 +1,149 @@
+// 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/v8.h"
+
+#include "src/interpreter/bytecode-dead-code-optimizer.h"
+#include "src/interpreter/bytecode-label.h"
+#include "src/objects.h"
+#include "test/unittests/test-utils.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+class BytecodeDeadCodeOptimizerTest : public BytecodePipelineStage,
+ public TestWithIsolateAndZone {
+ public:
+ BytecodeDeadCodeOptimizerTest() : dead_code_optimizer_(this) {}
+ ~BytecodeDeadCodeOptimizerTest() override {}
+
+ void Write(BytecodeNode* node) override {
+ write_count_++;
+ last_written_.Clone(node);
+ }
+
+ void WriteJump(BytecodeNode* node, BytecodeLabel* label) override {
+ write_count_++;
+ last_written_.Clone(node);
+ }
+
+ void BindLabel(BytecodeLabel* label) override {}
+ void BindLabel(const BytecodeLabel& target, BytecodeLabel* label) override {}
+ Handle<BytecodeArray> ToBytecodeArray(
+ int fixed_register_count, int parameter_count,
+ Handle<FixedArray> handle_table) override {
+ return Handle<BytecodeArray>();
+ }
+
+ BytecodeDeadCodeOptimizer* optimizer() { return &dead_code_optimizer_; }
+
+ int write_count() const { return write_count_; }
+ const BytecodeNode& last_written() const { return last_written_; }
+
+ private:
+ BytecodeDeadCodeOptimizer dead_code_optimizer_;
+
+ int write_count_ = 0;
+ BytecodeNode last_written_;
+};
+
+TEST_F(BytecodeDeadCodeOptimizerTest, LiveCodeKept) {
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(add, last_written());
+
+ BytecodeLabel target;
+ BytecodeNode jump(Bytecode::kJump, 0);
+ optimizer()->WriteJump(&jump, &target);
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(jump, last_written());
+}
+
+TEST_F(BytecodeDeadCodeOptimizerTest, DeadCodeAfterReturnEliminated) {
+ BytecodeNode ret(Bytecode::kReturn);
+ optimizer()->Write(&ret);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(ret, last_written());
+
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(ret, last_written());
+}
+
+TEST_F(BytecodeDeadCodeOptimizerTest, DeadCodeAfterThrowEliminated) {
+ BytecodeNode thrw(Bytecode::kThrow);
+ optimizer()->Write(&thrw);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(thrw, last_written());
+
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(thrw, last_written());
+}
+
+TEST_F(BytecodeDeadCodeOptimizerTest, DeadCodeAfterReThrowEliminated) {
+ BytecodeNode rethrow(Bytecode::kReThrow);
+ optimizer()->Write(&rethrow);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(rethrow, last_written());
+
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(rethrow, last_written());
+}
+
+TEST_F(BytecodeDeadCodeOptimizerTest, DeadCodeAfterJumpEliminated) {
+ BytecodeLabel target;
+ BytecodeNode jump(Bytecode::kJump, 0);
+ optimizer()->WriteJump(&jump, &target);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(jump, last_written());
+
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(jump, last_written());
+}
+
+TEST_F(BytecodeDeadCodeOptimizerTest, DeadCodeStillDeadAfterConditinalJump) {
+ BytecodeNode ret(Bytecode::kReturn);
+ optimizer()->Write(&ret);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(ret, last_written());
+
+ BytecodeLabel target;
+ BytecodeNode jump(Bytecode::kJumpIfTrue, 0);
+ optimizer()->WriteJump(&jump, &target);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(ret, last_written());
+
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(ret, last_written());
+}
+
+TEST_F(BytecodeDeadCodeOptimizerTest, CodeLiveAfterLabelBind) {
+ BytecodeNode ret(Bytecode::kReturn);
+ optimizer()->Write(&ret);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(ret, last_written());
+
+ BytecodeLabel target;
+ optimizer()->BindLabel(&target);
+
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(add, last_written());
+}
+
+} // namespace interpreter
+} // namespace internal
+} // namespace v8
diff --git a/test/unittests/interpreter/bytecode-peephole-optimizer-unittest.cc b/test/unittests/interpreter/bytecode-peephole-optimizer-unittest.cc
index cf4a920..671bdf8 100644
--- a/test/unittests/interpreter/bytecode-peephole-optimizer-unittest.cc
+++ b/test/unittests/interpreter/bytecode-peephole-optimizer-unittest.cc
@@ -5,6 +5,7 @@
#include "src/v8.h"
#include "src/factory.h"
+#include "src/interpreter/bytecode-label.h"
#include "src/interpreter/bytecode-peephole-optimizer.h"
#include "src/interpreter/constant-array-builder.h"
#include "src/objects-inl.h"
@@ -23,23 +24,31 @@
peephole_optimizer_(&constant_array_builder_, this) {}
~BytecodePeepholeOptimizerTest() override {}
- size_t FlushForOffset() override {
- flush_for_offset_count_++;
- return 0;
- };
-
- void FlushBasicBlock() override { flush_basic_block_count_++; }
-
void Write(BytecodeNode* node) override {
write_count_++;
last_written_.Clone(node);
}
+ void WriteJump(BytecodeNode* node, BytecodeLabel* label) override {
+ write_count_++;
+ last_written_.Clone(node);
+ }
+
+ void BindLabel(BytecodeLabel* label) override {}
+ void BindLabel(const BytecodeLabel& target, BytecodeLabel* label) override {}
+ Handle<BytecodeArray> ToBytecodeArray(
+ int fixed_register_count, int parameter_count,
+ Handle<FixedArray> handle_table) override {
+ return Handle<BytecodeArray>();
+ }
+
+ void Flush() {
+ optimizer()->ToBytecodeArray(0, 0, factory()->empty_fixed_array());
+ }
+
BytecodePeepholeOptimizer* optimizer() { return &peephole_optimizer_; }
ConstantArrayBuilder* constant_array() { return &constant_array_builder_; }
- int flush_for_offset_count() const { return flush_for_offset_count_; }
- int flush_basic_block_count() const { return flush_basic_block_count_; }
int write_count() const { return write_count_; }
const BytecodeNode& last_written() const { return last_written_; }
@@ -47,96 +56,98 @@
ConstantArrayBuilder constant_array_builder_;
BytecodePeepholeOptimizer peephole_optimizer_;
- int flush_for_offset_count_ = 0;
- int flush_basic_block_count_ = 0;
int write_count_ = 0;
BytecodeNode last_written_;
};
// Sanity tests.
-TEST_F(BytecodePeepholeOptimizerTest, FlushForOffsetPassThrough) {
- CHECK_EQ(flush_for_offset_count(), 0);
- CHECK_EQ(optimizer()->FlushForOffset(), 0);
- CHECK_EQ(flush_for_offset_count(), 1);
+TEST_F(BytecodePeepholeOptimizerTest, FlushOnJump) {
+ CHECK_EQ(write_count(), 0);
+
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
+ CHECK_EQ(write_count(), 0);
+
+ BytecodeLabel target;
+ BytecodeNode jump(Bytecode::kJump, 0);
+ optimizer()->WriteJump(&jump, &target);
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(jump, last_written());
}
-TEST_F(BytecodePeepholeOptimizerTest, FlushForOffsetRightSize) {
- BytecodeNode node(Bytecode::kAdd, Register(0).ToOperand(),
- OperandScale::kQuadruple);
- optimizer()->Write(&node);
- CHECK_EQ(optimizer()->FlushForOffset(), node.Size());
- CHECK_EQ(flush_for_offset_count(), 1);
+TEST_F(BytecodePeepholeOptimizerTest, FlushOnBind) {
CHECK_EQ(write_count(), 0);
-}
-TEST_F(BytecodePeepholeOptimizerTest, FlushForOffsetNop) {
- BytecodeNode node(Bytecode::kNop);
- optimizer()->Write(&node);
- CHECK_EQ(optimizer()->FlushForOffset(), 0);
- CHECK_EQ(flush_for_offset_count(), 1);
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
CHECK_EQ(write_count(), 0);
-}
-TEST_F(BytecodePeepholeOptimizerTest, FlushForOffsetNopExpression) {
- BytecodeNode node(Bytecode::kNop);
- node.source_info().Update({3, false});
- optimizer()->Write(&node);
- CHECK_EQ(optimizer()->FlushForOffset(), 0);
- CHECK_EQ(flush_for_offset_count(), 1);
- CHECK_EQ(write_count(), 0);
-}
-
-TEST_F(BytecodePeepholeOptimizerTest, FlushForOffsetNopStatement) {
- BytecodeNode node(Bytecode::kNop);
- node.source_info().Update({3, true});
- optimizer()->Write(&node);
- CHECK_EQ(optimizer()->FlushForOffset(), node.Size());
- CHECK_EQ(flush_for_offset_count(), 1);
- CHECK_EQ(write_count(), 0);
-}
-
-TEST_F(BytecodePeepholeOptimizerTest, FlushBasicBlockPassThrough) {
- CHECK_EQ(flush_basic_block_count(), 0);
- optimizer()->FlushBasicBlock();
- CHECK_EQ(flush_basic_block_count(), 1);
- CHECK_EQ(write_count(), 0);
-}
-
-TEST_F(BytecodePeepholeOptimizerTest, WriteOneFlushBasicBlock) {
- BytecodeNode node(Bytecode::kAdd, Register(0).ToOperand(),
- OperandScale::kQuadruple);
- optimizer()->Write(&node);
- CHECK_EQ(write_count(), 0);
- optimizer()->FlushBasicBlock();
+ BytecodeLabel target;
+ optimizer()->BindLabel(&target);
CHECK_EQ(write_count(), 1);
- CHECK_EQ(node, last_written());
+ CHECK_EQ(add, last_written());
+}
+
+// Nop elimination tests.
+
+TEST_F(BytecodePeepholeOptimizerTest, ElideEmptyNop) {
+ BytecodeNode nop(Bytecode::kNop);
+ optimizer()->Write(&nop);
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
+ Flush();
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(add, last_written());
+}
+
+TEST_F(BytecodePeepholeOptimizerTest, ElideExpressionNop) {
+ BytecodeNode nop(Bytecode::kNop);
+ nop.source_info().MakeExpressionPosition(3);
+ optimizer()->Write(&nop);
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ optimizer()->Write(&add);
+ Flush();
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(add, last_written());
+}
+
+TEST_F(BytecodePeepholeOptimizerTest, KeepStatementNop) {
+ BytecodeNode nop(Bytecode::kNop);
+ nop.source_info().MakeStatementPosition(3);
+ optimizer()->Write(&nop);
+ BytecodeNode add(Bytecode::kAdd, Register(0).ToOperand());
+ add.source_info().MakeExpressionPosition(3);
+ optimizer()->Write(&add);
+ Flush();
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(add, last_written());
}
// Tests covering BytecodePeepholeOptimizer::UpdateCurrentBytecode().
TEST_F(BytecodePeepholeOptimizerTest, KeepJumpIfToBooleanTrue) {
BytecodeNode first(Bytecode::kLdaNull);
- BytecodeNode second(Bytecode::kJumpIfToBooleanTrue, 3, OperandScale::kSingle);
+ BytecodeNode second(Bytecode::kJumpIfToBooleanTrue, 3);
optimizer()->Write(&first);
CHECK_EQ(write_count(), 0);
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 2);
CHECK_EQ(last_written(), second);
}
TEST_F(BytecodePeepholeOptimizerTest, ElideJumpIfToBooleanTrue) {
BytecodeNode first(Bytecode::kLdaTrue);
- BytecodeNode second(Bytecode::kJumpIfToBooleanTrue, 3, OperandScale::kSingle);
+ BytecodeNode second(Bytecode::kJumpIfToBooleanTrue, 3);
optimizer()->Write(&first);
CHECK_EQ(write_count(), 0);
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 2);
CHECK_EQ(last_written().bytecode(), Bytecode::kJumpIfTrue);
CHECK_EQ(last_written().operand(0), second.operand(0));
@@ -150,7 +161,7 @@
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 2);
CHECK_EQ(last_written(), second);
}
@@ -163,95 +174,81 @@
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 2);
CHECK_EQ(last_written().bytecode(), Bytecode::kLogicalNot);
}
// Tests covering BytecodePeepholeOptimizer::CanElideCurrent().
-TEST_F(BytecodePeepholeOptimizerTest, LdarRxLdarRy) {
- BytecodeNode first(Bytecode::kLdar, Register(0).ToOperand(),
- OperandScale::kSingle);
- BytecodeNode second(Bytecode::kLdar, Register(1).ToOperand(),
- OperandScale::kSingle);
+TEST_F(BytecodePeepholeOptimizerTest, StarRxLdarRy) {
+ BytecodeNode first(Bytecode::kStar, Register(0).ToOperand());
+ BytecodeNode second(Bytecode::kLdar, Register(1).ToOperand());
optimizer()->Write(&first);
- optimizer()->FlushForOffset(); // Prevent CanElideLast removing |first|.
CHECK_EQ(write_count(), 0);
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 2);
CHECK_EQ(last_written(), second);
}
-TEST_F(BytecodePeepholeOptimizerTest, LdarRxLdarRx) {
- BytecodeNode first(Bytecode::kLdar, Register(0).ToOperand(),
- OperandScale::kSingle);
- BytecodeNode second(Bytecode::kLdar, Register(0).ToOperand(),
- OperandScale::kSingle);
+TEST_F(BytecodePeepholeOptimizerTest, StarRxLdarRx) {
+ BytecodeLabel label;
+ BytecodeNode first(Bytecode::kStar, Register(0).ToOperand());
+ BytecodeNode second(Bytecode::kLdar, Register(0).ToOperand());
optimizer()->Write(&first);
CHECK_EQ(write_count(), 0);
- optimizer()->FlushForOffset(); // Prevent CanElideLast removing |first|.
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 1);
}
-TEST_F(BytecodePeepholeOptimizerTest, LdarRxLdarRxStatement) {
- BytecodeNode first(Bytecode::kLdar, Register(0).ToOperand(),
- OperandScale::kSingle);
- BytecodeNode second(Bytecode::kLdar, Register(0).ToOperand(),
- OperandScale::kSingle);
- second.source_info().Update({0, true});
+TEST_F(BytecodePeepholeOptimizerTest, StarRxLdarRxStatement) {
+ BytecodeNode first(Bytecode::kStar, Register(0).ToOperand());
+ BytecodeNode second(Bytecode::kLdar, Register(0).ToOperand());
+ second.source_info().MakeStatementPosition(0);
optimizer()->Write(&first);
CHECK_EQ(write_count(), 0);
- optimizer()->FlushForOffset(); // Prevent CanElideLast removing |first|.
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 2);
CHECK_EQ(last_written().bytecode(), Bytecode::kNop);
CHECK_EQ(last_written().source_info(), second.source_info());
}
-TEST_F(BytecodePeepholeOptimizerTest, LdarRxLdarRxStatementStarRy) {
- BytecodeNode first(Bytecode::kLdar, Register(0).ToOperand(),
- OperandScale::kSingle);
- BytecodeNode second(Bytecode::kLdar, Register(0).ToOperand(),
- OperandScale::kSingle);
- BytecodeNode third(Bytecode::kStar, Register(3).ToOperand(),
- OperandScale::kSingle);
- second.source_info().Update({0, true});
+TEST_F(BytecodePeepholeOptimizerTest, StarRxLdarRxStatementStarRy) {
+ BytecodeLabel label;
+ BytecodeNode first(Bytecode::kStar, Register(0).ToOperand());
+ BytecodeNode second(Bytecode::kLdar, Register(0).ToOperand());
+ BytecodeNode third(Bytecode::kStar, Register(3).ToOperand());
+ second.source_info().MakeStatementPosition(0);
optimizer()->Write(&first);
CHECK_EQ(write_count(), 0);
- optimizer()->FlushForOffset(); // Prevent CanElideLast removing |first|.
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
optimizer()->Write(&third);
CHECK_EQ(write_count(), 1);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 2);
- // Source position should move |second| to |third| when |second| is elided.
- third.source_info().Update(second.source_info());
CHECK_EQ(last_written(), third);
}
TEST_F(BytecodePeepholeOptimizerTest, LdarToName) {
- BytecodeNode first(Bytecode::kLdar, Register(0).ToOperand(),
- OperandScale::kSingle);
+ BytecodeNode first(Bytecode::kLdar, Register(0).ToOperand());
BytecodeNode second(Bytecode::kToName);
optimizer()->Write(&first);
CHECK_EQ(write_count(), 0);
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 2);
CHECK_EQ(last_written(), second);
}
@@ -264,7 +261,7 @@
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 1);
}
@@ -276,7 +273,7 @@
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 1);
}
@@ -284,50 +281,34 @@
Handle<Object> word =
isolate()->factory()->NewStringFromStaticChars("optimizing");
size_t index = constant_array()->Insert(word);
- BytecodeNode first(Bytecode::kLdaConstant, static_cast<uint32_t>(index),
- OperandScale::kSingle);
+ BytecodeNode first(Bytecode::kLdaConstant, static_cast<uint32_t>(index));
BytecodeNode second(Bytecode::kToName);
optimizer()->Write(&first);
CHECK_EQ(write_count(), 0);
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 1);
}
TEST_F(BytecodePeepholeOptimizerTest, LdaConstantNumberToName) {
Handle<Object> word = isolate()->factory()->NewNumber(0.380);
size_t index = constant_array()->Insert(word);
- BytecodeNode first(Bytecode::kLdaConstant, static_cast<uint32_t>(index),
- OperandScale::kSingle);
+ BytecodeNode first(Bytecode::kLdaConstant, static_cast<uint32_t>(index));
BytecodeNode second(Bytecode::kToName);
optimizer()->Write(&first);
CHECK_EQ(write_count(), 0);
optimizer()->Write(&second);
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 2);
CHECK_EQ(last_written(), second);
}
// Tests covering BytecodePeepholeOptimizer::CanElideLast().
-TEST_F(BytecodePeepholeOptimizerTest, LdaTrueLdaFalseNotDiscardable) {
- BytecodeNode first(Bytecode::kLdaTrue);
- BytecodeNode second(Bytecode::kLdaFalse);
- optimizer()->Write(&first);
- optimizer()->FlushForOffset(); // Prevent discarding of |first|.
- CHECK_EQ(write_count(), 0);
- optimizer()->Write(&second);
- CHECK_EQ(write_count(), 1);
- CHECK_EQ(last_written(), first);
- optimizer()->FlushBasicBlock();
- CHECK_EQ(write_count(), 2);
- CHECK_EQ(last_written(), second);
-}
-
TEST_F(BytecodePeepholeOptimizerTest, LdaTrueLdaFalse) {
BytecodeNode first(Bytecode::kLdaTrue);
BytecodeNode second(Bytecode::kLdaFalse);
@@ -335,23 +316,24 @@
CHECK_EQ(write_count(), 0);
optimizer()->Write(&second);
CHECK_EQ(write_count(), 0);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), second);
}
TEST_F(BytecodePeepholeOptimizerTest, LdaTrueStatementLdaFalse) {
BytecodeNode first(Bytecode::kLdaTrue);
- first.source_info().Update({3, false});
+ first.source_info().MakeExpressionPosition(3);
BytecodeNode second(Bytecode::kLdaFalse);
optimizer()->Write(&first);
CHECK_EQ(write_count(), 0);
optimizer()->Write(&second);
CHECK_EQ(write_count(), 0);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 1);
- second.source_info().Update(first.source_info());
CHECK_EQ(last_written(), second);
+ CHECK(second.source_info().is_expression());
+ CHECK_EQ(second.source_info().source_position(), 3);
}
TEST_F(BytecodePeepholeOptimizerTest, NopStackCheck) {
@@ -361,25 +343,152 @@
CHECK_EQ(write_count(), 0);
optimizer()->Write(&second);
CHECK_EQ(write_count(), 0);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 1);
CHECK_EQ(last_written(), second);
}
TEST_F(BytecodePeepholeOptimizerTest, NopStatementStackCheck) {
BytecodeNode first(Bytecode::kNop);
- first.source_info().Update({3, false});
+ first.source_info().MakeExpressionPosition(3);
BytecodeNode second(Bytecode::kStackCheck);
optimizer()->Write(&first);
CHECK_EQ(write_count(), 0);
optimizer()->Write(&second);
CHECK_EQ(write_count(), 0);
- optimizer()->FlushBasicBlock();
+ Flush();
CHECK_EQ(write_count(), 1);
- second.source_info().Update(first.source_info());
+ second.source_info().MakeExpressionPosition(
+ first.source_info().source_position());
CHECK_EQ(last_written(), second);
}
+// Tests covering BytecodePeepholeOptimizer::UpdateLastAndCurrentBytecodes().
+
+TEST_F(BytecodePeepholeOptimizerTest, MergeLoadICStar) {
+ const uint32_t operands[] = {
+ static_cast<uint32_t>(Register(31).ToOperand()), 32, 33,
+ static_cast<uint32_t>(Register(256).ToOperand())};
+ const int expected_operand_count = static_cast<int>(arraysize(operands));
+
+ BytecodeNode first(Bytecode::kLdaNamedProperty, operands[0], operands[1],
+ operands[2]);
+ BytecodeNode second(Bytecode::kStar, operands[3]);
+ BytecodeNode third(Bytecode::kReturn);
+ optimizer()->Write(&first);
+ optimizer()->Write(&second);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(last_written().bytecode(), Bytecode::kLdrNamedProperty);
+ CHECK_EQ(last_written().operand_count(), expected_operand_count);
+ for (int i = 0; i < expected_operand_count; ++i) {
+ CHECK_EQ(last_written().operand(i), operands[i]);
+ }
+ optimizer()->Write(&third);
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(last_written().bytecode(), Bytecode::kLdar);
+ CHECK_EQ(last_written().operand(0), operands[expected_operand_count - 1]);
+ Flush();
+ CHECK_EQ(last_written().bytecode(), third.bytecode());
+}
+
+TEST_F(BytecodePeepholeOptimizerTest, MergeLdaKeyedPropertyStar) {
+ const uint32_t operands[] = {static_cast<uint32_t>(Register(31).ToOperand()),
+ 9999997,
+ static_cast<uint32_t>(Register(1).ToOperand())};
+ const int expected_operand_count = static_cast<int>(arraysize(operands));
+
+ BytecodeNode first(Bytecode::kLdaKeyedProperty, operands[0], operands[1]);
+ BytecodeNode second(Bytecode::kStar, operands[2]);
+ BytecodeNode third(Bytecode::kReturn);
+ optimizer()->Write(&first);
+ optimizer()->Write(&second);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(last_written().bytecode(), Bytecode::kLdrKeyedProperty);
+ CHECK_EQ(last_written().operand_count(), expected_operand_count);
+ for (int i = 0; i < expected_operand_count; ++i) {
+ CHECK_EQ(last_written().operand(i), operands[i]);
+ }
+ optimizer()->Write(&third);
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(last_written().bytecode(), Bytecode::kLdar);
+ CHECK_EQ(last_written().operand(0), operands[expected_operand_count - 1]);
+ Flush();
+ CHECK_EQ(last_written().bytecode(), third.bytecode());
+}
+
+TEST_F(BytecodePeepholeOptimizerTest, MergeLdaGlobalStar) {
+ const uint32_t operands[] = {19191,
+ static_cast<uint32_t>(Register(1).ToOperand())};
+ const int expected_operand_count = static_cast<int>(arraysize(operands));
+
+ BytecodeNode first(Bytecode::kLdaGlobal, operands[0]);
+ BytecodeNode second(Bytecode::kStar, operands[1]);
+ BytecodeNode third(Bytecode::kReturn);
+ optimizer()->Write(&first);
+ optimizer()->Write(&second);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(last_written().bytecode(), Bytecode::kLdrGlobal);
+ CHECK_EQ(last_written().operand_count(), expected_operand_count);
+ for (int i = 0; i < expected_operand_count; ++i) {
+ CHECK_EQ(last_written().operand(i), operands[i]);
+ }
+ optimizer()->Write(&third);
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(last_written().bytecode(), Bytecode::kLdar);
+ CHECK_EQ(last_written().operand(0), operands[expected_operand_count - 1]);
+ Flush();
+ CHECK_EQ(last_written().bytecode(), third.bytecode());
+}
+
+TEST_F(BytecodePeepholeOptimizerTest, MergeLdaContextSlotStar) {
+ const uint32_t operands[] = {
+ static_cast<uint32_t>(Register(200000).ToOperand()), 55005500,
+ static_cast<uint32_t>(Register(1).ToOperand())};
+ const int expected_operand_count = static_cast<int>(arraysize(operands));
+
+ BytecodeNode first(Bytecode::kLdaContextSlot, operands[0], operands[1]);
+ BytecodeNode second(Bytecode::kStar, operands[2]);
+ BytecodeNode third(Bytecode::kReturn);
+ optimizer()->Write(&first);
+ optimizer()->Write(&second);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(last_written().bytecode(), Bytecode::kLdrContextSlot);
+ CHECK_EQ(last_written().operand_count(), expected_operand_count);
+ for (int i = 0; i < expected_operand_count; ++i) {
+ CHECK_EQ(last_written().operand(i), operands[i]);
+ }
+ optimizer()->Write(&third);
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(last_written().bytecode(), Bytecode::kLdar);
+ CHECK_EQ(last_written().operand(0), operands[expected_operand_count - 1]);
+ Flush();
+ CHECK_EQ(last_written().bytecode(), third.bytecode());
+}
+
+TEST_F(BytecodePeepholeOptimizerTest, MergeLdaUndefinedStar) {
+ const uint32_t operands[] = {
+ static_cast<uint32_t>(Register(100000).ToOperand())};
+ const int expected_operand_count = static_cast<int>(arraysize(operands));
+
+ BytecodeNode first(Bytecode::kLdaUndefined);
+ BytecodeNode second(Bytecode::kStar, operands[0]);
+ BytecodeNode third(Bytecode::kReturn);
+ optimizer()->Write(&first);
+ optimizer()->Write(&second);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(last_written().bytecode(), Bytecode::kLdrUndefined);
+ CHECK_EQ(last_written().operand_count(), expected_operand_count);
+ for (int i = 0; i < expected_operand_count; ++i) {
+ CHECK_EQ(last_written().operand(i), operands[i]);
+ }
+ optimizer()->Write(&third);
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(last_written().bytecode(), Bytecode::kLdar);
+ CHECK_EQ(last_written().operand(0), operands[expected_operand_count - 1]);
+ Flush();
+ CHECK_EQ(last_written().bytecode(), third.bytecode());
+}
+
} // namespace interpreter
} // namespace internal
} // namespace v8
diff --git a/test/unittests/interpreter/bytecode-pipeline-unittest.cc b/test/unittests/interpreter/bytecode-pipeline-unittest.cc
index f12391c..663b7e5 100644
--- a/test/unittests/interpreter/bytecode-pipeline-unittest.cc
+++ b/test/unittests/interpreter/bytecode-pipeline-unittest.cc
@@ -24,7 +24,7 @@
CHECK_EQ(x.is_statement(), false);
CHECK_EQ(x.is_valid(), false);
- x.Update({1, true});
+ x.MakeStatementPosition(1);
BytecodeSourceInfo y(1, true);
CHECK(x == y);
CHECK(!(x != y));
@@ -33,20 +33,20 @@
CHECK(!(x == y));
CHECK(x != y);
- y.Update({2, false});
+ y.MakeStatementPosition(1);
CHECK_EQ(y.source_position(), 1);
CHECK_EQ(y.is_statement(), true);
- y.Update({2, true});
+ y.MakeStatementPosition(2);
CHECK_EQ(y.source_position(), 2);
CHECK_EQ(y.is_statement(), true);
y.set_invalid();
- y.Update({3, false});
+ y.MakeExpressionPosition(3);
CHECK_EQ(y.source_position(), 3);
CHECK_EQ(y.is_statement(), false);
- y.Update({3, true});
+ y.MakeStatementPosition(3);
CHECK_EQ(y.source_position(), 3);
CHECK_EQ(y.is_statement(), true);
}
@@ -61,100 +61,88 @@
BytecodeNode node(Bytecode::kLdaZero);
CHECK_EQ(node.bytecode(), Bytecode::kLdaZero);
CHECK_EQ(node.operand_count(), 0);
- CHECK_EQ(node.operand_scale(), OperandScale::kSingle);
CHECK(!node.source_info().is_valid());
- CHECK_EQ(node.Size(), 1);
}
TEST_F(BytecodeNodeTest, Constructor2) {
uint32_t operands[] = {0x11};
- BytecodeNode node(Bytecode::kJumpIfTrue, operands[0], OperandScale::kDouble);
+ BytecodeNode node(Bytecode::kJumpIfTrue, operands[0]);
CHECK_EQ(node.bytecode(), Bytecode::kJumpIfTrue);
CHECK_EQ(node.operand_count(), 1);
CHECK_EQ(node.operand(0), operands[0]);
- CHECK_EQ(node.operand_scale(), OperandScale::kDouble);
CHECK(!node.source_info().is_valid());
- CHECK_EQ(node.Size(), 4);
}
TEST_F(BytecodeNodeTest, Constructor3) {
- uint32_t operands[] = {0x11, 0x22};
- BytecodeNode node(Bytecode::kLdaGlobal, operands[0], operands[1],
- OperandScale::kQuadruple);
+ uint32_t operands[] = {0x11};
+ BytecodeNode node(Bytecode::kLdaGlobal, operands[0]);
CHECK_EQ(node.bytecode(), Bytecode::kLdaGlobal);
- CHECK_EQ(node.operand_count(), 2);
+ CHECK_EQ(node.operand_count(), 1);
CHECK_EQ(node.operand(0), operands[0]);
- CHECK_EQ(node.operand(1), operands[1]);
- CHECK_EQ(node.operand_scale(), OperandScale::kQuadruple);
CHECK(!node.source_info().is_valid());
- CHECK_EQ(node.Size(), 10);
}
TEST_F(BytecodeNodeTest, Constructor4) {
uint32_t operands[] = {0x11, 0x22, 0x33};
- BytecodeNode node(Bytecode::kLoadIC, operands[0], operands[1], operands[2],
- OperandScale::kSingle);
+ BytecodeNode node(Bytecode::kLdaNamedProperty, operands[0], operands[1],
+ operands[2]);
CHECK_EQ(node.operand_count(), 3);
- CHECK_EQ(node.bytecode(), Bytecode::kLoadIC);
+ CHECK_EQ(node.bytecode(), Bytecode::kLdaNamedProperty);
CHECK_EQ(node.operand(0), operands[0]);
CHECK_EQ(node.operand(1), operands[1]);
CHECK_EQ(node.operand(2), operands[2]);
- CHECK_EQ(node.operand_scale(), OperandScale::kSingle);
CHECK(!node.source_info().is_valid());
- CHECK_EQ(node.Size(), 4);
}
TEST_F(BytecodeNodeTest, Constructor5) {
uint32_t operands[] = {0x71, 0xa5, 0x5a, 0xfc};
BytecodeNode node(Bytecode::kForInNext, operands[0], operands[1], operands[2],
- operands[3], OperandScale::kDouble);
+ operands[3]);
CHECK_EQ(node.operand_count(), 4);
CHECK_EQ(node.bytecode(), Bytecode::kForInNext);
CHECK_EQ(node.operand(0), operands[0]);
CHECK_EQ(node.operand(1), operands[1]);
CHECK_EQ(node.operand(2), operands[2]);
CHECK_EQ(node.operand(3), operands[3]);
- CHECK_EQ(node.operand_scale(), OperandScale::kDouble);
CHECK(!node.source_info().is_valid());
- CHECK_EQ(node.Size(), 10);
}
TEST_F(BytecodeNodeTest, Equality) {
uint32_t operands[] = {0x71, 0xa5, 0x5a, 0xfc};
BytecodeNode node(Bytecode::kForInNext, operands[0], operands[1], operands[2],
- operands[3], OperandScale::kDouble);
+ operands[3]);
CHECK_EQ(node, node);
BytecodeNode other(Bytecode::kForInNext, operands[0], operands[1],
- operands[2], operands[3], OperandScale::kDouble);
+ operands[2], operands[3]);
CHECK_EQ(node, other);
}
TEST_F(BytecodeNodeTest, EqualityWithSourceInfo) {
uint32_t operands[] = {0x71, 0xa5, 0x5a, 0xfc};
BytecodeNode node(Bytecode::kForInNext, operands[0], operands[1], operands[2],
- operands[3], OperandScale::kDouble);
- node.source_info().Update({3, true});
+ operands[3]);
+ node.source_info().MakeStatementPosition(3);
CHECK_EQ(node, node);
BytecodeNode other(Bytecode::kForInNext, operands[0], operands[1],
- operands[2], operands[3], OperandScale::kDouble);
- other.source_info().Update({3, true});
+ operands[2], operands[3]);
+ other.source_info().MakeStatementPosition(3);
CHECK_EQ(node, other);
}
TEST_F(BytecodeNodeTest, NoEqualityWithDifferentSourceInfo) {
uint32_t operands[] = {0x71, 0xa5, 0x5a, 0xfc};
BytecodeNode node(Bytecode::kForInNext, operands[0], operands[1], operands[2],
- operands[3], OperandScale::kDouble);
- node.source_info().Update({3, true});
+ operands[3]);
+ node.source_info().MakeStatementPosition(3);
BytecodeNode other(Bytecode::kForInNext, operands[0], operands[1],
- operands[2], operands[3], OperandScale::kDouble);
+ operands[2], operands[3]);
CHECK_NE(node, other);
}
TEST_F(BytecodeNodeTest, Clone) {
uint32_t operands[] = {0x71, 0xa5, 0x5a, 0xfc};
BytecodeNode node(Bytecode::kForInNext, operands[0], operands[1], operands[2],
- operands[3], OperandScale::kDouble);
+ operands[3]);
BytecodeNode clone;
clone.Clone(&node);
CHECK_EQ(clone, node);
@@ -163,33 +151,32 @@
TEST_F(BytecodeNodeTest, SetBytecode0) {
uint32_t operands[] = {0x71, 0xa5, 0x5a, 0xfc};
BytecodeNode node(Bytecode::kForInNext, operands[0], operands[1], operands[2],
- operands[3], OperandScale::kDouble);
+ operands[3]);
BytecodeSourceInfo source_info(77, false);
- node.source_info().Update(source_info);
+ node.source_info().Clone(source_info);
+ CHECK_EQ(node.source_info(), source_info);
BytecodeNode clone;
clone.Clone(&node);
clone.set_bytecode(Bytecode::kNop);
CHECK_EQ(clone.bytecode(), Bytecode::kNop);
CHECK_EQ(clone.operand_count(), 0);
- CHECK_EQ(clone.operand_scale(), OperandScale::kSingle);
CHECK_EQ(clone.source_info(), source_info);
}
TEST_F(BytecodeNodeTest, SetBytecode1) {
uint32_t operands[] = {0x71, 0xa5, 0x5a, 0xfc};
BytecodeNode node(Bytecode::kForInNext, operands[0], operands[1], operands[2],
- operands[3], OperandScale::kDouble);
+ operands[3]);
BytecodeSourceInfo source_info(77, false);
- node.source_info().Update(source_info);
+ node.source_info().Clone(source_info);
BytecodeNode clone;
clone.Clone(&node);
- clone.set_bytecode(Bytecode::kJump, 0x01aabbcc, OperandScale::kQuadruple);
+ clone.set_bytecode(Bytecode::kJump, 0x01aabbcc);
CHECK_EQ(clone.bytecode(), Bytecode::kJump);
CHECK_EQ(clone.operand_count(), 1);
CHECK_EQ(clone.operand(0), 0x01aabbcc);
- CHECK_EQ(clone.operand_scale(), OperandScale::kQuadruple);
CHECK_EQ(clone.source_info(), source_info);
}
diff --git a/test/unittests/interpreter/bytecode-register-optimizer-unittest.cc b/test/unittests/interpreter/bytecode-register-optimizer-unittest.cc
new file mode 100644
index 0000000..795bee8
--- /dev/null
+++ b/test/unittests/interpreter/bytecode-register-optimizer-unittest.cc
@@ -0,0 +1,219 @@
+// 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/v8.h"
+
+#include "src/factory.h"
+#include "src/interpreter/bytecode-label.h"
+#include "src/interpreter/bytecode-register-optimizer.h"
+#include "src/objects-inl.h"
+#include "src/objects.h"
+#include "test/unittests/test-utils.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+class BytecodeRegisterOptimizerTest : public BytecodePipelineStage,
+ public TestWithIsolateAndZone {
+ public:
+ BytecodeRegisterOptimizerTest() {}
+ ~BytecodeRegisterOptimizerTest() override { delete register_allocator_; }
+
+ void Initialize(int number_of_parameters, int number_of_locals) {
+ register_allocator_ =
+ new TemporaryRegisterAllocator(zone(), number_of_locals);
+ register_optimizer_ = new (zone()) BytecodeRegisterOptimizer(
+ zone(), register_allocator_, number_of_parameters, this);
+ }
+
+ void Write(BytecodeNode* node) override { output_.push_back(*node); }
+ void WriteJump(BytecodeNode* node, BytecodeLabel* label) override {
+ output_.push_back(*node);
+ }
+ void BindLabel(BytecodeLabel* label) override {}
+ void BindLabel(const BytecodeLabel& target, BytecodeLabel* label) override {}
+ Handle<BytecodeArray> ToBytecodeArray(
+ int fixed_register_count, int parameter_count,
+ Handle<FixedArray> handle_table) override {
+ return Handle<BytecodeArray>();
+ }
+
+ TemporaryRegisterAllocator* allocator() { return register_allocator_; }
+ BytecodeRegisterOptimizer* optimizer() { return register_optimizer_; }
+
+ Register NewTemporary() {
+ return Register(allocator()->BorrowTemporaryRegister());
+ }
+
+ void KillTemporary(Register reg) {
+ allocator()->ReturnTemporaryRegister(reg.index());
+ }
+
+ size_t write_count() const { return output_.size(); }
+ const BytecodeNode& last_written() const { return output_.back(); }
+ const std::vector<BytecodeNode>* output() { return &output_; }
+
+ private:
+ TemporaryRegisterAllocator* register_allocator_;
+ BytecodeRegisterOptimizer* register_optimizer_;
+
+ std::vector<BytecodeNode> output_;
+};
+
+// Sanity tests.
+
+TEST_F(BytecodeRegisterOptimizerTest, WriteNop) {
+ Initialize(1, 1);
+ BytecodeNode node(Bytecode::kNop);
+ optimizer()->Write(&node);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(node, last_written());
+}
+
+TEST_F(BytecodeRegisterOptimizerTest, WriteNopExpression) {
+ Initialize(1, 1);
+ BytecodeNode node(Bytecode::kNop);
+ node.source_info().MakeExpressionPosition(3);
+ optimizer()->Write(&node);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(node, last_written());
+}
+
+TEST_F(BytecodeRegisterOptimizerTest, WriteNopStatement) {
+ Initialize(1, 1);
+ BytecodeNode node(Bytecode::kNop);
+ node.source_info().MakeStatementPosition(3);
+ optimizer()->Write(&node);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(node, last_written());
+}
+
+TEST_F(BytecodeRegisterOptimizerTest, TemporaryMaterializedForJump) {
+ Initialize(1, 1);
+ Register temp = NewTemporary();
+ BytecodeNode node(Bytecode::kStar, temp.ToOperand());
+ optimizer()->Write(&node);
+ CHECK_EQ(write_count(), 0);
+ BytecodeLabel label;
+ BytecodeNode jump(Bytecode::kJump, 0);
+ optimizer()->WriteJump(&jump, &label);
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(output()->at(0).bytecode(), Bytecode::kStar);
+ CHECK_EQ(output()->at(0).operand(0), temp.ToOperand());
+ CHECK_EQ(output()->at(1).bytecode(), Bytecode::kJump);
+}
+
+TEST_F(BytecodeRegisterOptimizerTest, TemporaryMaterializedForBind) {
+ Initialize(1, 1);
+ Register temp = NewTemporary();
+ BytecodeNode node(Bytecode::kStar, temp.ToOperand());
+ optimizer()->Write(&node);
+ CHECK_EQ(write_count(), 0);
+ BytecodeLabel label;
+ optimizer()->BindLabel(&label);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(output()->at(0).bytecode(), Bytecode::kStar);
+ CHECK_EQ(output()->at(0).operand(0), temp.ToOperand());
+}
+
+// Basic Register Optimizations
+
+TEST_F(BytecodeRegisterOptimizerTest, TemporaryNotEmitted) {
+ Initialize(3, 1);
+ Register parameter = Register::FromParameterIndex(1, 3);
+ BytecodeNode node0(Bytecode::kLdar, parameter.ToOperand());
+ optimizer()->Write(&node0);
+ CHECK_EQ(write_count(), 0);
+ Register temp = NewTemporary();
+ BytecodeNode node1(Bytecode::kStar, NewTemporary().ToOperand());
+ optimizer()->Write(&node1);
+ CHECK_EQ(write_count(), 0);
+ KillTemporary(temp);
+ CHECK_EQ(write_count(), 0);
+ BytecodeNode node2(Bytecode::kReturn);
+ optimizer()->Write(&node2);
+ CHECK_EQ(write_count(), 2);
+ CHECK_EQ(output()->at(0).bytecode(), Bytecode::kLdar);
+ CHECK_EQ(output()->at(0).operand(0), parameter.ToOperand());
+ CHECK_EQ(output()->at(1).bytecode(), Bytecode::kReturn);
+}
+
+TEST_F(BytecodeRegisterOptimizerTest, StoresToLocalsImmediate) {
+ Initialize(3, 1);
+ Register parameter = Register::FromParameterIndex(1, 3);
+ BytecodeNode node0(Bytecode::kLdar, parameter.ToOperand());
+ optimizer()->Write(&node0);
+ CHECK_EQ(write_count(), 0);
+ Register local = Register(0);
+ BytecodeNode node1(Bytecode::kStar, local.ToOperand());
+ optimizer()->Write(&node1);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(output()->at(0).bytecode(), Bytecode::kMov);
+ CHECK_EQ(output()->at(0).operand(0), parameter.ToOperand());
+ CHECK_EQ(output()->at(0).operand(1), local.ToOperand());
+
+ BytecodeNode node2(Bytecode::kReturn);
+ optimizer()->Write(&node2);
+ CHECK_EQ(write_count(), 3);
+ CHECK_EQ(output()->at(1).bytecode(), Bytecode::kLdar);
+ CHECK_EQ(output()->at(1).operand(0), local.ToOperand());
+ CHECK_EQ(output()->at(2).bytecode(), Bytecode::kReturn);
+}
+
+TEST_F(BytecodeRegisterOptimizerTest, TemporaryNotMaterializedForInput) {
+ Initialize(3, 1);
+ Register parameter = Register::FromParameterIndex(1, 3);
+ Register temp0 = NewTemporary();
+ Register temp1 = NewTemporary();
+ BytecodeNode node0(Bytecode::kMov, parameter.ToOperand(), temp0.ToOperand());
+ optimizer()->Write(&node0);
+ BytecodeNode node1(Bytecode::kMov, parameter.ToOperand(), temp1.ToOperand());
+ optimizer()->Write(&node1);
+ CHECK_EQ(write_count(), 0);
+ BytecodeNode node2(Bytecode::kCallJSRuntime, 0, temp0.ToOperand(), 1);
+ optimizer()->Write(&node2);
+ CHECK_EQ(write_count(), 1);
+ CHECK_EQ(output()->at(0).bytecode(), Bytecode::kCallJSRuntime);
+ CHECK_EQ(output()->at(0).operand(0), 0);
+ CHECK_EQ(output()->at(0).operand(1), parameter.ToOperand());
+ CHECK_EQ(output()->at(0).operand(2), 1);
+}
+
+TEST_F(BytecodeRegisterOptimizerTest, RangeOfTemporariesMaterializedForInput) {
+ Initialize(3, 1);
+ Register parameter = Register::FromParameterIndex(1, 3);
+ Register temp0 = NewTemporary();
+ Register temp1 = NewTemporary();
+ BytecodeNode node0(Bytecode::kLdaSmi, 3);
+ optimizer()->Write(&node0);
+ CHECK_EQ(write_count(), 1);
+ BytecodeNode node1(Bytecode::kStar, temp0.ToOperand());
+ optimizer()->Write(&node1);
+ BytecodeNode node2(Bytecode::kMov, parameter.ToOperand(), temp1.ToOperand());
+ optimizer()->Write(&node2);
+ CHECK_EQ(write_count(), 1);
+ BytecodeNode node3(Bytecode::kCallJSRuntime, 0, temp0.ToOperand(), 2);
+ optimizer()->Write(&node3);
+ CHECK_EQ(write_count(), 4);
+
+ CHECK_EQ(output()->at(0).bytecode(), Bytecode::kLdaSmi);
+ CHECK_EQ(output()->at(0).operand(0), 3);
+
+ CHECK_EQ(output()->at(1).bytecode(), Bytecode::kStar);
+ CHECK_EQ(output()->at(1).operand(0), temp0.ToOperand());
+
+ CHECK_EQ(output()->at(2).bytecode(), Bytecode::kMov);
+ CHECK_EQ(output()->at(2).operand(0), parameter.ToOperand());
+ CHECK_EQ(output()->at(2).operand(1), temp1.ToOperand());
+
+ CHECK_EQ(output()->at(3).bytecode(), Bytecode::kCallJSRuntime);
+ CHECK_EQ(output()->at(3).operand(0), 0);
+ CHECK_EQ(output()->at(3).operand(1), temp0.ToOperand());
+ CHECK_EQ(output()->at(3).operand(2), 2);
+}
+
+} // namespace interpreter
+} // namespace internal
+} // namespace v8
diff --git a/test/unittests/interpreter/bytecodes-unittest.cc b/test/unittests/interpreter/bytecodes-unittest.cc
index eebacb2..74a2bb3 100644
--- a/test/unittests/interpreter/bytecodes-unittest.cc
+++ b/test/unittests/interpreter/bytecodes-unittest.cc
@@ -254,35 +254,6 @@
}
}
-TEST(Bytecodes, OperandScales) {
- CHECK_EQ(Bytecodes::OperandSizesToScale(OperandSize::kByte),
- OperandScale::kSingle);
- CHECK_EQ(Bytecodes::OperandSizesToScale(OperandSize::kShort),
- OperandScale::kDouble);
- CHECK_EQ(Bytecodes::OperandSizesToScale(OperandSize::kQuad),
- OperandScale::kQuadruple);
- CHECK_EQ(
- Bytecodes::OperandSizesToScale(OperandSize::kShort, OperandSize::kShort,
- OperandSize::kShort, OperandSize::kShort),
- OperandScale::kDouble);
- CHECK_EQ(
- Bytecodes::OperandSizesToScale(OperandSize::kQuad, OperandSize::kShort,
- OperandSize::kShort, OperandSize::kShort),
- OperandScale::kQuadruple);
- CHECK_EQ(
- Bytecodes::OperandSizesToScale(OperandSize::kShort, OperandSize::kQuad,
- OperandSize::kShort, OperandSize::kShort),
- OperandScale::kQuadruple);
- CHECK_EQ(
- Bytecodes::OperandSizesToScale(OperandSize::kShort, OperandSize::kShort,
- OperandSize::kQuad, OperandSize::kShort),
- OperandScale::kQuadruple);
- CHECK_EQ(
- Bytecodes::OperandSizesToScale(OperandSize::kShort, OperandSize::kShort,
- OperandSize::kShort, OperandSize::kQuad),
- OperandScale::kQuadruple);
-}
-
TEST(Bytecodes, SizesForSignedOperands) {
CHECK(Bytecodes::SizeForSignedOperand(0) == OperandSize::kByte);
CHECK(Bytecodes::SizeForSignedOperand(kMaxInt8) == OperandSize::kByte);
@@ -366,7 +337,6 @@
names.insert(Bytecodes::AccumulatorUseToString(AccumulatorUse::kReadWrite));
CHECK_EQ(names.size(), 4);
}
-
} // namespace interpreter
} // namespace internal
} // namespace v8
diff --git a/test/unittests/interpreter/constant-array-builder-unittest.cc b/test/unittests/interpreter/constant-array-builder-unittest.cc
index 7122437..c48ac58 100644
--- a/test/unittests/interpreter/constant-array-builder-unittest.cc
+++ b/test/unittests/interpreter/constant-array-builder-unittest.cc
@@ -89,7 +89,7 @@
}
for (size_t i = 0; i < reserved; i++) {
size_t index = k8BitCapacity - reserved + i;
- CHECK(builder.At(index)->IsTheHole());
+ CHECK(builder.At(index)->IsTheHole(isolate()));
}
// Now make reservations, and commit them with unique entries.
diff --git a/test/unittests/interpreter/interpreter-assembler-unittest.cc b/test/unittests/interpreter/interpreter-assembler-unittest.cc
index cd21f09..1bc80c0 100644
--- a/test/unittests/interpreter/interpreter-assembler-unittest.cc
+++ b/test/unittests/interpreter/interpreter-assembler-unittest.cc
@@ -428,6 +428,10 @@
EXPECT_THAT(m.BytecodeOperandRuntimeId(i),
m.IsUnsignedOperand(offset, operand_size));
break;
+ case interpreter::OperandType::kIntrinsicId:
+ EXPECT_THAT(m.BytecodeOperandIntrinsicId(i),
+ m.IsUnsignedOperand(offset, operand_size));
+ break;
case interpreter::OperandType::kNone:
UNREACHABLE();
break;
@@ -692,16 +696,14 @@
m.IsLoad(MachineType::AnyTagged(), IsLoadParentFramePointer(),
IsIntPtrConstant(Register::function_closure().ToOperand()
<< kPointerSizeLog2));
- Matcher<Node*> load_shared_function_info_matcher =
- m.IsLoad(MachineType::AnyTagged(), load_function_matcher,
- IsIntPtrConstant(JSFunction::kSharedFunctionInfoOffset -
- kHeapObjectTag));
+ Matcher<Node*> load_literals_matcher = m.IsLoad(
+ MachineType::AnyTagged(), load_function_matcher,
+ IsIntPtrConstant(JSFunction::kLiteralsOffset - kHeapObjectTag));
- EXPECT_THAT(
- feedback_vector,
- m.IsLoad(MachineType::AnyTagged(), load_shared_function_info_matcher,
- IsIntPtrConstant(SharedFunctionInfo::kFeedbackVectorOffset -
- kHeapObjectTag)));
+ EXPECT_THAT(feedback_vector,
+ m.IsLoad(MachineType::AnyTagged(), load_literals_matcher,
+ IsIntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
+ kHeapObjectTag)));
}
}
diff --git a/test/unittests/interpreter/source-position-table-unittest.cc b/test/unittests/interpreter/source-position-table-unittest.cc
index 230e57d..87d58fd 100644
--- a/test/unittests/interpreter/source-position-table-unittest.cc
+++ b/test/unittests/interpreter/source-position-table-unittest.cc
@@ -56,23 +56,26 @@
TEST_F(SourcePositionTableTest, EncodeAscending) {
SourcePositionTableBuilder builder(isolate(), zone());
- int accumulator = 0;
+ int code_offset = 0;
+ int source_position = 0;
for (int i = 0; i < arraysize(offsets); i++) {
- accumulator += offsets[i];
+ code_offset += offsets[i];
+ source_position += offsets[i];
if (i % 2) {
- builder.AddPosition(accumulator, accumulator, true);
+ builder.AddPosition(code_offset, source_position, true);
} else {
- builder.AddPosition(accumulator, accumulator, false);
+ builder.AddPosition(code_offset, source_position, false);
}
}
- // Also test negative offsets:
+ // Also test negative offsets for source positions:
for (int i = 0; i < arraysize(offsets); i++) {
- accumulator -= offsets[i];
+ code_offset += offsets[i];
+ source_position -= offsets[i];
if (i % 2) {
- builder.AddPosition(accumulator, accumulator, true);
+ builder.AddPosition(code_offset, source_position, true);
} else {
- builder.AddPosition(accumulator, accumulator, false);
+ builder.AddPosition(code_offset, source_position, false);
}
}
diff --git a/test/unittests/register-configuration-unittest.cc b/test/unittests/register-configuration-unittest.cc
new file mode 100644
index 0000000..31333ee
--- /dev/null
+++ b/test/unittests/register-configuration-unittest.cc
@@ -0,0 +1,130 @@
+// 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/register-configuration.h"
+#include "testing/gtest-support.h"
+
+namespace v8 {
+namespace internal {
+
+const MachineRepresentation kFloat32 = MachineRepresentation::kFloat32;
+const MachineRepresentation kFloat64 = MachineRepresentation::kFloat64;
+
+class RegisterConfigurationUnitTest : public ::testing::Test {
+ public:
+ RegisterConfigurationUnitTest() {}
+ virtual ~RegisterConfigurationUnitTest() {}
+
+ private:
+};
+
+TEST_F(RegisterConfigurationUnitTest, BasicProperties) {
+ const int kNumGeneralRegs = 3;
+ const int kNumDoubleRegs = 4;
+ const int kNumAllocatableGeneralRegs = 2;
+ const int kNumAllocatableDoubleRegs = 2;
+ int general_codes[kNumAllocatableGeneralRegs] = {1, 2};
+ int double_codes[kNumAllocatableDoubleRegs] = {2, 3};
+
+ RegisterConfiguration test(
+ kNumGeneralRegs, kNumDoubleRegs, kNumAllocatableGeneralRegs,
+ kNumAllocatableDoubleRegs, general_codes, double_codes,
+ RegisterConfiguration::OVERLAP, nullptr, nullptr, nullptr);
+
+ EXPECT_EQ(test.num_general_registers(), kNumGeneralRegs);
+ EXPECT_EQ(test.num_double_registers(), kNumDoubleRegs);
+ EXPECT_EQ(test.num_allocatable_general_registers(),
+ kNumAllocatableGeneralRegs);
+ EXPECT_EQ(test.num_allocatable_double_registers(), kNumAllocatableDoubleRegs);
+ EXPECT_EQ(test.num_allocatable_float_registers(), kNumAllocatableDoubleRegs);
+
+ EXPECT_EQ(test.allocatable_general_codes_mask(),
+ (1 << general_codes[0]) | (1 << general_codes[1]));
+ EXPECT_EQ(test.GetAllocatableGeneralCode(0), general_codes[0]);
+ EXPECT_EQ(test.GetAllocatableGeneralCode(1), general_codes[1]);
+ EXPECT_EQ(test.allocatable_double_codes_mask(),
+ (1 << double_codes[0]) | (1 << double_codes[1]));
+ EXPECT_EQ(test.GetAllocatableDoubleCode(0), double_codes[0]);
+ EXPECT_EQ(test.GetAllocatableDoubleCode(1), double_codes[1]);
+}
+
+TEST_F(RegisterConfigurationUnitTest, Aliasing) {
+ const int kNumGeneralRegs = 3;
+ const int kNumDoubleRegs = 4;
+ const int kNumAllocatableGeneralRegs = 2;
+ const int kNumAllocatableDoubleRegs = 3;
+ int general_codes[] = {1, 2};
+ int double_codes[] = {2, 3, 16}; // reg 16 should not alias registers 32, 33.
+
+ RegisterConfiguration test(
+ kNumGeneralRegs, kNumDoubleRegs, kNumAllocatableGeneralRegs,
+ kNumAllocatableDoubleRegs, general_codes, double_codes,
+ RegisterConfiguration::COMBINE, nullptr, nullptr, nullptr);
+
+ // There are 3 allocatable double regs, but only 2 can alias float regs.
+ EXPECT_EQ(test.num_allocatable_float_registers(), 4);
+
+ // Test that float registers combine in pairs to form double registers.
+ EXPECT_EQ(test.GetAllocatableFloatCode(0), double_codes[0] * 2);
+ EXPECT_EQ(test.GetAllocatableFloatCode(1), double_codes[0] * 2 + 1);
+ EXPECT_EQ(test.GetAllocatableFloatCode(2), double_codes[1] * 2);
+ EXPECT_EQ(test.GetAllocatableFloatCode(3), double_codes[1] * 2 + 1);
+
+ // Registers alias themselves.
+ EXPECT_TRUE(test.AreAliases(kFloat32, 0, kFloat32, 0));
+ EXPECT_TRUE(test.AreAliases(kFloat64, 0, kFloat64, 0));
+ // Registers don't alias other registers of the same size.
+ EXPECT_FALSE(test.AreAliases(kFloat32, 1, kFloat32, 0));
+ EXPECT_FALSE(test.AreAliases(kFloat64, 1, kFloat64, 0));
+ // Float registers combine in pairs and alias double registers.
+ EXPECT_TRUE(test.AreAliases(kFloat32, 0, kFloat64, 0));
+ EXPECT_TRUE(test.AreAliases(kFloat32, 1, kFloat64, 0));
+ EXPECT_TRUE(test.AreAliases(kFloat64, 0, kFloat32, 0));
+ EXPECT_TRUE(test.AreAliases(kFloat64, 0, kFloat32, 1));
+
+ EXPECT_FALSE(test.AreAliases(kFloat32, 0, kFloat64, 1));
+ EXPECT_FALSE(test.AreAliases(kFloat32, 1, kFloat64, 1));
+
+ EXPECT_TRUE(test.AreAliases(kFloat64, 0, kFloat32, 1));
+ EXPECT_TRUE(test.AreAliases(kFloat64, 1, kFloat32, 2));
+ EXPECT_TRUE(test.AreAliases(kFloat64, 1, kFloat32, 3));
+ EXPECT_TRUE(test.AreAliases(kFloat64, 2, kFloat32, 4));
+ EXPECT_TRUE(test.AreAliases(kFloat64, 2, kFloat32, 5));
+
+ int alias_base_index = -1;
+ EXPECT_EQ(test.GetAliases(kFloat32, 0, kFloat32, &alias_base_index), 1);
+ EXPECT_EQ(alias_base_index, 0);
+ EXPECT_EQ(test.GetAliases(kFloat64, 1, kFloat64, &alias_base_index), 1);
+ EXPECT_EQ(alias_base_index, 1);
+ EXPECT_EQ(test.GetAliases(kFloat32, 0, kFloat64, &alias_base_index), 1);
+ EXPECT_EQ(alias_base_index, 0);
+ EXPECT_EQ(test.GetAliases(kFloat32, 1, kFloat64, &alias_base_index), 1);
+ EXPECT_EQ(test.GetAliases(kFloat32, 2, kFloat64, &alias_base_index), 1);
+ EXPECT_EQ(alias_base_index, 1);
+ EXPECT_EQ(test.GetAliases(kFloat32, 3, kFloat64, &alias_base_index), 1);
+ EXPECT_EQ(alias_base_index, 1);
+ EXPECT_EQ(test.GetAliases(kFloat64, 0, kFloat32, &alias_base_index), 2);
+ EXPECT_EQ(alias_base_index, 0);
+ EXPECT_EQ(test.GetAliases(kFloat64, 1, kFloat32, &alias_base_index), 2);
+ EXPECT_EQ(alias_base_index, 2);
+
+ // Non-allocatable codes still alias.
+ EXPECT_EQ(test.GetAliases(kFloat64, 2, kFloat32, &alias_base_index), 2);
+ EXPECT_EQ(alias_base_index, 4);
+ // High numbered double registers don't alias nonexistent single registers.
+ EXPECT_EQ(
+ test.GetAliases(kFloat64, RegisterConfiguration::kMaxFPRegisters / 2,
+ kFloat32, &alias_base_index),
+ 0);
+ EXPECT_EQ(
+ test.GetAliases(kFloat64, RegisterConfiguration::kMaxFPRegisters / 2 + 1,
+ kFloat32, &alias_base_index),
+ 0);
+ EXPECT_EQ(test.GetAliases(kFloat64, RegisterConfiguration::kMaxFPRegisters,
+ kFloat32, &alias_base_index),
+ 0);
+}
+
+} // namespace internal
+} // namespace v8
diff --git a/test/unittests/unittests.gyp b/test/unittests/unittests.gyp
index e16ebeb..d5ba353 100644
--- a/test/unittests/unittests.gyp
+++ b/test/unittests/unittests.gyp
@@ -2,6 +2,8 @@
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
+# Please keep this file in sync with BUILD.gn.
+
{
'variables': {
'v8_code': 1,
@@ -29,6 +31,7 @@
'base/division-by-constant-unittest.cc',
'base/flags-unittest.cc',
'base/functional-unittest.cc',
+ 'base/ieee754-unittest.cc',
'base/logging-unittest.cc',
'base/iterator-unittest.cc',
'base/platform/condition-variable-unittest.cc',
@@ -41,7 +44,7 @@
'cancelable-tasks-unittest.cc',
'char-predicates-unittest.cc',
'compiler/branch-elimination-unittest.cc',
- 'compiler/coalesced-live-ranges-unittest.cc',
+ 'compiler/checkpoint-elimination-unittest.cc',
'compiler/common-operator-reducer-unittest.cc',
'compiler/common-operator-unittest.cc',
'compiler/compiler-test-utils.h',
@@ -97,9 +100,11 @@
'interpreter/bytecode-array-builder-unittest.cc',
'interpreter/bytecode-array-iterator-unittest.cc',
'interpreter/bytecode-array-writer-unittest.cc',
+ 'interpreter/bytecode-dead-code-optimizer-unittest.cc',
'interpreter/bytecode-peephole-optimizer-unittest.cc',
- 'interpreter/bytecode-register-allocator-unittest.cc',
'interpreter/bytecode-pipeline-unittest.cc',
+ 'interpreter/bytecode-register-allocator-unittest.cc',
+ 'interpreter/bytecode-register-optimizer-unittest.cc',
'interpreter/constant-array-builder-unittest.cc',
'interpreter/interpreter-assembler-unittest.cc',
'interpreter/interpreter-assembler-unittest.h',
@@ -115,10 +120,13 @@
'heap/scavenge-job-unittest.cc',
'heap/slot-set-unittest.cc',
'locked-queue-unittest.cc',
+ 'register-configuration-unittest.cc',
'run-all-unittests.cc',
'test-utils.h',
'test-utils.cc',
+ 'wasm/asm-types-unittest.cc',
'wasm/ast-decoder-unittest.cc',
+ 'wasm/control-transfer-unittest.cc',
'wasm/decoder-unittest.cc',
'wasm/encoder-unittest.cc',
'wasm/leb-helper-unittest.cc',
diff --git a/test/unittests/unittests.status b/test/unittests/unittests.status
index 84fd087..6d67439 100644
--- a/test/unittests/unittests.status
+++ b/test/unittests/unittests.status
@@ -12,4 +12,9 @@
'AstDecoderTest.AllLoadMemCombinations': [SKIP],
'AstDecoderTest.AllStoreMemCombinations': [SKIP],
}], # 'byteorder == big'
+['arch == x87', {
+ 'Ieee754.Expm1': [SKIP],
+ 'Ieee754.Cos': [SKIP],
+ 'Ieee754.Tan': [SKIP],
+}], # 'arch == x87'
]
diff --git a/test/unittests/wasm/asm-types-unittest.cc b/test/unittests/wasm/asm-types-unittest.cc
new file mode 100644
index 0000000..9b29362
--- /dev/null
+++ b/test/unittests/wasm/asm-types-unittest.cc
@@ -0,0 +1,729 @@
+// 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/asm-types.h"
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "src/base/macros.h"
+#include "test/unittests/test-utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace v8 {
+namespace internal {
+namespace wasm {
+namespace {
+
+using ::testing::StrEq;
+
+class AsmTypeTest : public TestWithZone {
+ public:
+ using Type = AsmType;
+
+ AsmTypeTest()
+ : parents_({
+ {Type::Uint8Array(), {Type::Heap()}},
+ {Type::Int8Array(), {Type::Heap()}},
+ {Type::Uint16Array(), {Type::Heap()}},
+ {Type::Int16Array(), {Type::Heap()}},
+ {Type::Uint32Array(), {Type::Heap()}},
+ {Type::Int32Array(), {Type::Heap()}},
+ {Type::Float32Array(), {Type::Heap()}},
+ {Type::Float64Array(), {Type::Heap()}},
+ {Type::FloatishDoubleQ(), {Type::Floatish(), Type::DoubleQ()}},
+ {Type::FloatQDoubleQ(),
+ {Type::FloatQ(), Type::Floatish(), Type::DoubleQ()}},
+ {Type::Float(), {Type::FloatQ(), Type::Floatish()}},
+ {Type::FloatQ(), {Type::Floatish()}},
+ {Type::FixNum(),
+ {Type::Signed(), Type::Extern(), Type::Unsigned(), Type::Int(),
+ Type::Intish()}},
+ {Type::Unsigned(), {Type::Int(), Type::Intish()}},
+ {Type::Signed(), {Type::Extern(), Type::Int(), Type::Intish()}},
+ {Type::Int(), {Type::Intish()}},
+ {Type::Double(), {Type::DoubleQ(), Type::Extern()}},
+ }) {}
+
+ protected:
+ std::unordered_set<Type*> ParentsOf(Type* derived) const {
+ const auto parents_iter = parents_.find(derived);
+ if (parents_iter == parents_.end()) {
+ return std::unordered_set<Type*>();
+ }
+ return parents_iter->second;
+ }
+
+ class FunctionTypeBuilder {
+ public:
+ FunctionTypeBuilder(FunctionTypeBuilder&& b)
+ : function_type_(b.function_type_) {
+ b.function_type_ = nullptr;
+ }
+
+ FunctionTypeBuilder& operator=(FunctionTypeBuilder&& b) {
+ if (this != &b) {
+ function_type_ = b.function_type_;
+ b.function_type_ = nullptr;
+ }
+ return *this;
+ }
+
+ FunctionTypeBuilder(Zone* zone, Type* return_type)
+ : function_type_(Type::Function(zone, return_type)) {}
+
+ private:
+ static void AddAllArguments(AsmFunctionType*) {}
+
+ template <typename Arg, typename... Others>
+ static void AddAllArguments(AsmFunctionType* function_type, Arg* arg,
+ Others... others) {
+ CHECK(function_type != nullptr);
+ function_type->AddArgument((*arg)());
+ AddAllArguments(function_type, others...);
+ }
+
+ public:
+ template <typename... Args>
+ Type* operator()(Args... args) {
+ Type* ret = function_type_;
+ function_type_ = nullptr;
+ AddAllArguments(ret->AsFunctionType(), args...);
+ return ret;
+ }
+
+ private:
+ Type* function_type_;
+ };
+
+ FunctionTypeBuilder Function(Type* (*return_type)()) {
+ return FunctionTypeBuilder(zone(), (*return_type)());
+ }
+
+ template <typename... Overloads>
+ Type* Overload(Overloads... overloads) {
+ auto* ret = Type::OverloadedFunction(zone());
+ AddAllOverloads(ret->AsOverloadedFunctionType(), overloads...);
+ return ret;
+ }
+
+ private:
+ static void AddAllOverloads(AsmOverloadedFunctionType*) {}
+
+ template <typename Overload, typename... Others>
+ static void AddAllOverloads(AsmOverloadedFunctionType* function,
+ Overload* overload, Others... others) {
+ CHECK(function != nullptr);
+ function->AddOverload(overload);
+ AddAllOverloads(function, others...);
+ }
+
+ const std::unordered_map<Type*, std::unordered_set<Type*>> parents_;
+};
+
+// AsmValueTypeParents expose the bitmasks for the parents for each value type
+// in asm's type system. It inherits from AsmValueType so that the kAsm<Foo>
+// members are available when expanding the FOR_EACH_ASM_VALUE_TYPE_LIST macro.
+class AsmValueTypeParents : private AsmValueType {
+ public:
+ enum : uint32_t {
+#define V(CamelName, string_name, number, parent_types) \
+ CamelName = parent_types,
+ FOR_EACH_ASM_VALUE_TYPE_LIST(V)
+#undef V
+ };
+
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(AsmValueTypeParents);
+};
+
+TEST_F(AsmTypeTest, ValidateBits) {
+ // Generic validation tests for the bits in the type system's type
+ // definitions.
+
+ std::unordered_set<Type*> seen_types;
+ std::unordered_set<uint32_t> seen_numbers;
+ uint32_t total_types = 0;
+#define V(CamelName, string_name, number, parent_types) \
+ do { \
+ ++total_types; \
+ if (AsmValueTypeParents::CamelName != 0) { \
+ EXPECT_NE(0, ParentsOf(AsmType::CamelName()).size()) << #CamelName; \
+ } \
+ seen_types.insert(Type::CamelName()); \
+ seen_numbers.insert(number); \
+ /* Every ASM type must have a valid number. */ \
+ EXPECT_NE(0, number) << Type::CamelName()->Name(); \
+ /* Inheritance cycles - unlikely, but we're paranoid and check for it */ \
+ /* anyways.*/ \
+ EXPECT_EQ(0, (1 << (number)) & AsmValueTypeParents::CamelName); \
+ } while (0);
+ FOR_EACH_ASM_VALUE_TYPE_LIST(V)
+#undef V
+
+ // At least one type was expanded.
+ EXPECT_GT(total_types, 0u);
+
+ // Each value type is unique.
+ EXPECT_EQ(total_types, seen_types.size());
+
+ // Each number is unique.
+ EXPECT_EQ(total_types, seen_numbers.size());
+}
+
+TEST_F(AsmTypeTest, SaneParentsMap) {
+ // This test ensures our parents map contains all the parents types that are
+ // specified in the types' declaration. It does not report bogus inheritance.
+
+ // Handy-dandy lambda for counting bits. Code borrowed from stack overflow.
+ auto NumberOfSetBits = [](uintptr_t parent_mask) -> uint32_t {
+ uint32_t parent_mask32 = static_cast<uint32_t>(parent_mask);
+ CHECK_EQ(parent_mask, parent_mask32);
+ parent_mask32 = parent_mask32 - ((parent_mask32 >> 1) & 0x55555555);
+ parent_mask32 =
+ (parent_mask32 & 0x33333333) + ((parent_mask32 >> 2) & 0x33333333);
+ return (((parent_mask32 + (parent_mask32 >> 4)) & 0x0F0F0F0F) *
+ 0x01010101) >>
+ 24;
+ };
+
+#define V(CamelName, string_name, number, parent_types) \
+ do { \
+ const uintptr_t parents = \
+ reinterpret_cast<uintptr_t>(Type::CamelName()) & ~(1 << (number)); \
+ EXPECT_EQ(NumberOfSetBits(parents), \
+ 1 + ParentsOf(Type::CamelName()).size()) \
+ << Type::CamelName()->Name() << ", parents " \
+ << reinterpret_cast<void*>(parents) << ", type " \
+ << static_cast<void*>(Type::CamelName()); \
+ } while (0);
+ FOR_EACH_ASM_VALUE_TYPE_LIST(V)
+#undef V
+}
+
+TEST_F(AsmTypeTest, Names) {
+#define V(CamelName, string_name, number, parent_types) \
+ do { \
+ EXPECT_THAT(Type::CamelName()->Name(), StrEq(string_name)); \
+ } while (0);
+ FOR_EACH_ASM_VALUE_TYPE_LIST(V)
+#undef V
+
+ EXPECT_THAT(Function(Type::Int)(Type::Double, Type::Float)->Name(),
+ StrEq("(double, float) -> int"));
+
+ EXPECT_THAT(Overload(Function(Type::Int)(Type::Double, Type::Float),
+ Function(Type::Int)(Type::Int))
+ ->Name(),
+ StrEq("(double, float) -> int /\\ (int) -> int"));
+
+ EXPECT_THAT(Type::FroundType(zone())->Name(), StrEq("fround"));
+
+ EXPECT_THAT(Type::MinMaxType(zone(), Type::Signed(), Type::Int())->Name(),
+ StrEq("(int, int...) -> signed"));
+ EXPECT_THAT(Type::MinMaxType(zone(), Type::Float(), Type::Floatish())->Name(),
+ StrEq("(floatish, floatish...) -> float"));
+ EXPECT_THAT(Type::MinMaxType(zone(), Type::Double(), Type::DoubleQ())->Name(),
+ StrEq("(double?, double?...) -> double"));
+
+ EXPECT_THAT(Type::FFIType(zone())->Name(), StrEq("Function"));
+
+ auto* ft =
+ Type::FunctionTableType(zone(), 15, Function(Type::Double)(Type::Int));
+ EXPECT_THAT(ft->Name(), StrEq("(int) -> double[15]"));
+}
+
+TEST_F(AsmTypeTest, IsExactly) {
+ Type* test_types[] = {
+#define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
+ FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
+#undef CREATE
+ Function(Type::Int)(Type::Double),
+ Function(Type::Int)(Type::DoubleQ),
+ Overload(Function(Type::Int)(Type::Double)),
+ Function(Type::Int)(Type::Int, Type::Int),
+ Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+ Function(Type::Int)(Type::Float), Type::FroundType(zone()),
+ Type::FFIType(zone()),
+ Type::FunctionTableType(zone(), 10, Function(Type::Void)()),
+ };
+
+ for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
+ for (size_t jj = 0; jj < arraysize(test_types); ++jj) {
+ EXPECT_EQ(ii == jj, test_types[ii]->IsExactly(test_types[jj]))
+ << test_types[ii]->Name()
+ << ((ii == jj) ? " is not exactly " : " is exactly ")
+ << test_types[jj]->Name();
+ }
+ }
+}
+
+TEST_F(AsmTypeTest, IsA) {
+ Type* test_types[] = {
+#define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
+ FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
+#undef CREATE
+ Function(Type::Int)(Type::Double),
+ Function(Type::Int)(Type::DoubleQ),
+ Overload(Function(Type::Int)(Type::Double)),
+ Function(Type::Int)(Type::Int, Type::Int),
+ Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+ Function(Type::Int)(Type::Float), Type::FroundType(zone()),
+ Type::FFIType(zone()),
+ Type::FunctionTableType(zone(), 10, Function(Type::Void)()),
+ };
+
+ for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
+ for (size_t jj = 0; jj < arraysize(test_types); ++jj) {
+ const bool Expected =
+ (ii == jj) || ParentsOf(test_types[ii]).count(test_types[jj]) != 0;
+ EXPECT_EQ(Expected, test_types[ii]->IsA(test_types[jj]))
+ << test_types[ii]->Name() << (Expected ? " is not a " : " is a ")
+ << test_types[jj]->Name();
+ }
+ }
+}
+
+TEST_F(AsmTypeTest, ValidateCall) {
+ auto* min_max_int = Type::MinMaxType(zone(), Type::Signed(), Type::Int());
+ auto* i2s = Function(Type::Signed)(Type::Int);
+ auto* ii2s = Function(Type::Signed)(Type::Int, Type::Int);
+ auto* iii2s = Function(Type::Signed)(Type::Int, Type::Int, Type::Int);
+ auto* iiii2s =
+ Function(Type::Signed)(Type::Int, Type::Int, Type::Int, Type::Int);
+
+ EXPECT_EQ(Type::Signed(), min_max_int->AsCallableType()->ValidateCall(
+ min_max_int->AsFunctionType()->ReturnType(),
+ min_max_int->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Signed(), min_max_int->AsCallableType()->ValidateCall(
+ ii2s->AsFunctionType()->ReturnType(),
+ ii2s->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Signed(), min_max_int->AsCallableType()->ValidateCall(
+ iii2s->AsFunctionType()->ReturnType(),
+ iii2s->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Signed(), min_max_int->AsCallableType()->ValidateCall(
+ iiii2s->AsFunctionType()->ReturnType(),
+ iiii2s->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::None(), min_max_int->AsCallableType()->ValidateCall(
+ i2s->AsFunctionType()->ReturnType(),
+ i2s->AsFunctionType()->Arguments()));
+
+ auto* min_max_double =
+ Type::MinMaxType(zone(), Type::Double(), Type::Double());
+ auto* d2d = Function(Type::Double)(Type::Double);
+ auto* dd2d = Function(Type::Double)(Type::Double, Type::Double);
+ auto* ddd2d =
+ Function(Type::Double)(Type::Double, Type::Double, Type::Double);
+ auto* dddd2d = Function(Type::Double)(Type::Double, Type::Double,
+ Type::Double, Type::Double);
+ EXPECT_EQ(Type::Double(), min_max_double->AsCallableType()->ValidateCall(
+ min_max_double->AsFunctionType()->ReturnType(),
+ min_max_double->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Double(), min_max_double->AsCallableType()->ValidateCall(
+ dd2d->AsFunctionType()->ReturnType(),
+ dd2d->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Double(), min_max_double->AsCallableType()->ValidateCall(
+ ddd2d->AsFunctionType()->ReturnType(),
+ ddd2d->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Double(), min_max_double->AsCallableType()->ValidateCall(
+ dddd2d->AsFunctionType()->ReturnType(),
+ dddd2d->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::None(), min_max_double->AsCallableType()->ValidateCall(
+ d2d->AsFunctionType()->ReturnType(),
+ d2d->AsFunctionType()->Arguments()));
+
+ auto* min_max = Overload(min_max_int, min_max_double);
+ EXPECT_EQ(Type::None(), min_max->AsCallableType()->ValidateCall(
+ i2s->AsFunctionType()->ReturnType(),
+ i2s->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::None(), min_max->AsCallableType()->ValidateCall(
+ d2d->AsFunctionType()->ReturnType(),
+ d2d->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Signed(), min_max->AsCallableType()->ValidateCall(
+ min_max_int->AsFunctionType()->ReturnType(),
+ min_max_int->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Signed(), min_max->AsCallableType()->ValidateCall(
+ ii2s->AsFunctionType()->ReturnType(),
+ ii2s->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Signed(), min_max->AsCallableType()->ValidateCall(
+ iii2s->AsFunctionType()->ReturnType(),
+ iii2s->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Signed(), min_max->AsCallableType()->ValidateCall(
+ iiii2s->AsFunctionType()->ReturnType(),
+ iiii2s->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Double(), min_max->AsCallableType()->ValidateCall(
+ min_max_double->AsFunctionType()->ReturnType(),
+ min_max_double->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Double(), min_max->AsCallableType()->ValidateCall(
+ dd2d->AsFunctionType()->ReturnType(),
+ dd2d->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Double(), min_max->AsCallableType()->ValidateCall(
+ ddd2d->AsFunctionType()->ReturnType(),
+ ddd2d->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Double(), min_max->AsCallableType()->ValidateCall(
+ dddd2d->AsFunctionType()->ReturnType(),
+ dddd2d->AsFunctionType()->Arguments()));
+
+ auto* fround = Type::FroundType(zone());
+
+ ZoneVector<AsmType*> arg(zone());
+ arg.push_back(Type::Floatish());
+ EXPECT_EQ(Type::Float(),
+ fround->AsCallableType()->ValidateCall(Type::Float(), arg));
+ arg.clear();
+ arg.push_back(Type::FloatQ());
+ EXPECT_EQ(Type::Float(),
+ fround->AsCallableType()->ValidateCall(Type::Float(), arg));
+ arg.clear();
+ arg.push_back(Type::Float());
+ EXPECT_EQ(Type::Float(),
+ fround->AsCallableType()->ValidateCall(Type::Float(), arg));
+ arg.clear();
+ arg.push_back(Type::DoubleQ());
+ EXPECT_EQ(Type::Float(),
+ fround->AsCallableType()->ValidateCall(Type::Float(), arg));
+ arg.clear();
+ arg.push_back(Type::Double());
+ EXPECT_EQ(Type::Float(),
+ fround->AsCallableType()->ValidateCall(Type::Float(), arg));
+ arg.clear();
+ arg.push_back(Type::Signed());
+ EXPECT_EQ(Type::Float(),
+ fround->AsCallableType()->ValidateCall(Type::Float(), arg));
+ arg.clear();
+ arg.push_back(Type::Unsigned());
+ EXPECT_EQ(Type::Float(),
+ fround->AsCallableType()->ValidateCall(Type::Float(), arg));
+ arg.clear();
+ arg.push_back(Type::FixNum());
+ EXPECT_EQ(Type::Float(),
+ fround->AsCallableType()->ValidateCall(Type::Float(), arg));
+
+ auto* idf2v = Function(Type::Void)(Type::Int, Type::Double, Type::Float);
+ auto* i2d = Function(Type::Double)(Type::Int);
+ auto* i2f = Function(Type::Float)(Type::Int);
+ auto* fi2d = Function(Type::Double)(Type::Float, Type::Int);
+ auto* idif2i =
+ Function(Type::Int)(Type::Int, Type::Double, Type::Int, Type::Float);
+ auto* overload = Overload(idf2v, i2f, /*i2d missing, */ fi2d, idif2i);
+ EXPECT_EQ(Type::Void(), overload->AsCallableType()->ValidateCall(
+ idf2v->AsFunctionType()->ReturnType(),
+ idf2v->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Float(), overload->AsCallableType()->ValidateCall(
+ i2f->AsFunctionType()->ReturnType(),
+ i2f->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Double(), overload->AsCallableType()->ValidateCall(
+ fi2d->AsFunctionType()->ReturnType(),
+ fi2d->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::Int(), overload->AsCallableType()->ValidateCall(
+ idif2i->AsFunctionType()->ReturnType(),
+ idif2i->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::None(), overload->AsCallableType()->ValidateCall(
+ i2d->AsFunctionType()->ReturnType(),
+ i2d->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::None(), i2f->AsCallableType()->ValidateCall(
+ i2d->AsFunctionType()->ReturnType(),
+ i2d->AsFunctionType()->Arguments()));
+
+ auto* ffi = Type::FFIType(zone());
+ AsmType* (*kReturnTypes[])() = {
+ Type::Void, Type::Double, Type::Signed,
+ };
+ AsmType* (*kParameterTypes[])() = {
+ Type::Double, Type::Signed, Type::FixNum,
+ };
+ for (size_t ii = 0; ii < arraysize(kReturnTypes); ++ii) {
+ for (size_t jj = 0; jj < arraysize(kParameterTypes); ++jj) {
+ auto* f = Function(kReturnTypes[ii])(kParameterTypes[jj]);
+ EXPECT_EQ(kReturnTypes[ii](), ffi->AsCallableType()->ValidateCall(
+ f->AsFunctionType()->ReturnType(),
+ f->AsFunctionType()->Arguments()))
+ << kReturnTypes[ii]()->Name();
+
+ // Call with non-parameter type type should fail.
+ f = Function(kReturnTypes[ii])(kParameterTypes[jj], Type::Int);
+ EXPECT_EQ(Type::None(), ffi->AsCallableType()->ValidateCall(
+ f->AsFunctionType()->ReturnType(),
+ f->AsFunctionType()->Arguments()))
+ << kReturnTypes[ii]()->Name();
+ }
+ }
+
+ auto* ft0 = Type::FunctionTableType(zone(), 10, fi2d);
+ EXPECT_EQ(Type::Double(), ft0->AsCallableType()->ValidateCall(
+ fi2d->AsFunctionType()->ReturnType(),
+ fi2d->AsFunctionType()->Arguments()));
+ EXPECT_EQ(Type::None(), ft0->AsCallableType()->ValidateCall(
+ i2d->AsFunctionType()->ReturnType(),
+ i2d->AsFunctionType()->Arguments()));
+}
+
+TEST_F(AsmTypeTest, ToReturnType) {
+ std::unordered_map<AsmType*, AsmType*> kToReturnType = {
+ {Type::Signed(), Type::Signed()}, {Type::FixNum(), Type::Signed()},
+ {Type::Double(), Type::Double()}, {Type::Float(), Type::Float()},
+ {Type::Void(), Type::Void()},
+ };
+
+ Type* test_types[] = {
+#define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
+ FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
+#undef CREATE
+ Function(Type::Int)(Type::Double),
+ Function(Type::Int)(Type::DoubleQ),
+ Overload(Function(Type::Int)(Type::Double)),
+ Function(Type::Int)(Type::Int, Type::Int),
+ Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+ Function(Type::Int)(Type::Float), Type::FroundType(zone()),
+ Type::FFIType(zone()),
+ Type::FunctionTableType(zone(), 10, Function(Type::Void)()),
+ };
+
+ for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
+ auto* return_type = Type::None();
+ auto to_return_type_iter = kToReturnType.find(test_types[ii]);
+ if (to_return_type_iter != kToReturnType.end()) {
+ return_type = to_return_type_iter->second;
+ }
+ EXPECT_EQ(return_type, test_types[ii]->ToReturnType())
+ << return_type->Name() << " != " << test_types[ii]->ToReturnType();
+ }
+}
+
+TEST_F(AsmTypeTest, IsReturnType) {
+ Type* test_types[] = {
+#define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
+ FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
+#undef CREATE
+ Function(Type::Int)(Type::Double),
+ Function(Type::Int)(Type::DoubleQ),
+ Overload(Function(Type::Int)(Type::Double)),
+ Function(Type::Int)(Type::Int, Type::Int),
+ Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+ Function(Type::Int)(Type::Float), Type::FroundType(zone()),
+ Type::FFIType(zone()),
+ Type::FunctionTableType(zone(), 10, Function(Type::Void)()),
+ };
+
+ std::unordered_set<Type*> return_types{
+ Type::Double(), Type::Signed(), Type::Float(), Type::Void(),
+ };
+
+ for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
+ const bool IsReturnType = return_types.count(test_types[ii]);
+ EXPECT_EQ(IsReturnType, test_types[ii]->IsReturnType())
+ << test_types[ii]->Name()
+ << (IsReturnType ? " is not a return type" : " is a return type");
+ }
+}
+
+TEST_F(AsmTypeTest, ToParameterType) {
+ std::unordered_map<AsmType*, AsmType*> kToParameterType = {
+ {Type::Int(), Type::Int()}, {Type::Signed(), Type::Int()},
+ {Type::Unsigned(), Type::Int()}, {Type::FixNum(), Type::Int()},
+ {Type::Double(), Type::Double()}, {Type::Float(), Type::Float()},
+ };
+
+ Type* test_types[] = {
+#define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
+ FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
+#undef CREATE
+ Function(Type::Int)(Type::Double),
+ Function(Type::Int)(Type::DoubleQ),
+ Overload(Function(Type::Int)(Type::Double)),
+ Function(Type::Int)(Type::Int, Type::Int),
+ Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+ Function(Type::Int)(Type::Float), Type::FroundType(zone()),
+ Type::FFIType(zone()),
+ Type::FunctionTableType(zone(), 10, Function(Type::Void)()),
+ };
+
+ for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
+ auto* parameter_type = Type::None();
+ auto to_parameter_type_iter = kToParameterType.find(test_types[ii]);
+ if (to_parameter_type_iter != kToParameterType.end()) {
+ parameter_type = to_parameter_type_iter->second;
+ }
+ EXPECT_EQ(parameter_type, test_types[ii]->ToParameterType())
+ << parameter_type->Name()
+ << " != " << test_types[ii]->ToParameterType();
+ }
+}
+
+TEST_F(AsmTypeTest, IsParameterType) {
+ Type* test_types[] = {
+#define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
+ FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
+#undef CREATE
+ Function(Type::Int)(Type::Double),
+ Function(Type::Int)(Type::DoubleQ),
+ Overload(Function(Type::Int)(Type::Double)),
+ Function(Type::Int)(Type::Int, Type::Int),
+ Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+ Function(Type::Int)(Type::Float), Type::FroundType(zone()),
+ Type::FFIType(zone()),
+ Type::FunctionTableType(zone(), 10, Function(Type::Void)()),
+ };
+
+ std::unordered_set<Type*> parameter_types{
+ Type::Double(), Type::Int(), Type::Float(),
+ };
+
+ for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
+ const bool IsParameterType = parameter_types.count(test_types[ii]);
+ EXPECT_EQ(IsParameterType, test_types[ii]->IsParameterType())
+ << test_types[ii]->Name()
+ << (IsParameterType ? " is not a parameter type"
+ : " is a parameter type");
+ }
+}
+
+TEST_F(AsmTypeTest, IsComparableType) {
+ Type* test_types[] = {
+#define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
+ FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
+#undef CREATE
+ Function(Type::Int)(Type::Double),
+ Function(Type::Int)(Type::DoubleQ),
+ Overload(Function(Type::Int)(Type::Double)),
+ Function(Type::Int)(Type::Int, Type::Int),
+ Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+ Function(Type::Int)(Type::Float), Type::FroundType(zone()),
+ Type::FFIType(zone()),
+ Type::FunctionTableType(zone(), 10, Function(Type::Void)()),
+ };
+
+ std::unordered_set<Type*> comparable_types{
+ Type::Double(), Type::Signed(), Type::Unsigned(), Type::Float(),
+ };
+
+ for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
+ const bool IsComparableType = comparable_types.count(test_types[ii]);
+ EXPECT_EQ(IsComparableType, test_types[ii]->IsComparableType())
+ << test_types[ii]->Name()
+ << (IsComparableType ? " is not a comparable type"
+ : " is a comparable type");
+ }
+}
+
+TEST_F(AsmTypeTest, ElementSizeInBytes) {
+ Type* test_types[] = {
+#define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
+ FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
+#undef CREATE
+ Function(Type::Int)(Type::Double),
+ Function(Type::Int)(Type::DoubleQ),
+ Overload(Function(Type::Int)(Type::Double)),
+ Function(Type::Int)(Type::Int, Type::Int),
+ Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+ Function(Type::Int)(Type::Float), Type::FroundType(zone()),
+ Type::FFIType(zone()),
+ Type::FunctionTableType(zone(), 10, Function(Type::Void)()),
+ };
+
+ auto ElementSizeInBytesForType = [](Type* type) -> int32_t {
+ if (type == Type::Int8Array() || type == Type::Uint8Array()) {
+ return 1;
+ }
+ if (type == Type::Int16Array() || type == Type::Uint16Array()) {
+ return 2;
+ }
+ if (type == Type::Int32Array() || type == Type::Uint32Array() ||
+ type == Type::Float32Array()) {
+ return 4;
+ }
+ if (type == Type::Float64Array()) {
+ return 8;
+ }
+ return -1;
+ };
+
+ for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
+ EXPECT_EQ(ElementSizeInBytesForType(test_types[ii]),
+ test_types[ii]->ElementSizeInBytes());
+ }
+}
+
+TEST_F(AsmTypeTest, LoadType) {
+ Type* test_types[] = {
+#define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
+ FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
+#undef CREATE
+ Function(Type::Int)(Type::Double),
+ Function(Type::Int)(Type::DoubleQ),
+ Overload(Function(Type::Int)(Type::Double)),
+ Function(Type::Int)(Type::Int, Type::Int),
+ Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+ Function(Type::Int)(Type::Float), Type::FroundType(zone()),
+ Type::FFIType(zone()),
+ Type::FunctionTableType(zone(), 10, Function(Type::Void)()),
+ };
+
+ auto LoadTypeForType = [](Type* type) -> Type* {
+ if (type == Type::Int8Array() || type == Type::Uint8Array() ||
+ type == Type::Int16Array() || type == Type::Uint16Array() ||
+ type == Type::Int32Array() || type == Type::Uint32Array()) {
+ return Type::Intish();
+ }
+
+ if (type == Type::Float32Array()) {
+ return Type::FloatQ();
+ }
+
+ if (type == Type::Float64Array()) {
+ return Type::DoubleQ();
+ }
+
+ return Type::None();
+ };
+
+ for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
+ EXPECT_EQ(LoadTypeForType(test_types[ii]), test_types[ii]->LoadType());
+ }
+}
+
+TEST_F(AsmTypeTest, StoreType) {
+ Type* test_types[] = {
+#define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
+ FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
+#undef CREATE
+ Function(Type::Int)(Type::Double),
+ Function(Type::Int)(Type::DoubleQ),
+ Overload(Function(Type::Int)(Type::Double)),
+ Function(Type::Int)(Type::Int, Type::Int),
+ Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+ Function(Type::Int)(Type::Float), Type::FroundType(zone()),
+ Type::FFIType(zone()),
+ Type::FunctionTableType(zone(), 10, Function(Type::Void)()),
+ };
+
+ auto StoreTypeForType = [](Type* type) -> Type* {
+ if (type == Type::Int8Array() || type == Type::Uint8Array() ||
+ type == Type::Int16Array() || type == Type::Uint16Array() ||
+ type == Type::Int32Array() || type == Type::Uint32Array()) {
+ return Type::Intish();
+ }
+
+ if (type == Type::Float32Array()) {
+ return Type::FloatishDoubleQ();
+ }
+
+ if (type == Type::Float64Array()) {
+ return Type::FloatQDoubleQ();
+ }
+
+ return Type::None();
+ };
+
+ for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
+ EXPECT_EQ(StoreTypeForType(test_types[ii]), test_types[ii]->StoreType())
+ << test_types[ii]->Name();
+ }
+}
+
+} // namespace
+} // namespace wasm
+} // namespace internal
+} // namespace v8
diff --git a/test/unittests/wasm/ast-decoder-unittest.cc b/test/unittests/wasm/ast-decoder-unittest.cc
index fe10115..8be0e41 100644
--- a/test/unittests/wasm/ast-decoder-unittest.cc
+++ b/test/unittests/wasm/ast-decoder-unittest.cc
@@ -82,7 +82,7 @@
// verification failures.
void Verify(ErrorCode expected, FunctionSig* sig, const byte* start,
const byte* end) {
- local_decls.Prepend(&start, &end);
+ local_decls.Prepend(zone(), &start, &end);
// Verify the code.
TreeResult result =
VerifyWasmCode(zone()->allocator(), module, sig, start, end);
@@ -105,8 +105,6 @@
}
FATAL(str.str().c_str());
}
-
- delete[] start; // local_decls.Prepend() allocated a new buffer.
}
void TestBinop(WasmOpcode opcode, FunctionSig* success) {
@@ -1158,7 +1156,6 @@
TestModuleEnv() {
instance = nullptr;
module = &mod;
- linker = nullptr;
}
byte AddGlobal(MachineType mem_type) {
mod.globals.push_back({0, 0, mem_type, 0, false});
@@ -1171,14 +1168,13 @@
return static_cast<byte>(mod.signatures.size() - 1);
}
byte AddFunction(FunctionSig* sig) {
- mod.functions.push_back({sig, // sig
- 0, // func_index
- 0, // sig_index
- 0, // name_offset
- 0, // name_length
- 0, // code_start_offset
- 0, // code_end_offset
- false}); // exported
+ mod.functions.push_back({sig, // sig
+ 0, // func_index
+ 0, // sig_index
+ 0, // name_offset
+ 0, // name_length
+ 0, // code_start_offset
+ 0}); // code_end_offset
CHECK(mod.functions.size() <= 127);
return static_cast<byte>(mod.functions.size() - 1);
}
@@ -2427,7 +2423,7 @@
local_decls.AddLocals(5, kAstF32);
local_decls.AddLocals(1337, kAstI32);
local_decls.AddLocals(212, kAstI64);
- local_decls.Prepend(&data, &end);
+ local_decls.Prepend(zone(), &data, &end);
AstLocalDecls decls(zone());
bool result = DecodeLocalDecls(decls, data, end);
@@ -2439,7 +2435,6 @@
pos = ExpectRun(map, pos, kAstF32, 5);
pos = ExpectRun(map, pos, kAstI32, 1337);
pos = ExpectRun(map, pos, kAstI64, 212);
- delete[] data;
}
} // namespace wasm
diff --git a/test/unittests/wasm/control-transfer-unittest.cc b/test/unittests/wasm/control-transfer-unittest.cc
new file mode 100644
index 0000000..2b67f12
--- /dev/null
+++ b/test/unittests/wasm/control-transfer-unittest.cc
@@ -0,0 +1,402 @@
+// 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 "test/unittests/test-utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+#include "src/v8.h"
+
+#include "src/wasm/wasm-interpreter.h"
+#include "src/wasm/wasm-macro-gen.h"
+
+using testing::MakeMatcher;
+using testing::Matcher;
+using testing::MatcherInterface;
+using testing::MatchResultListener;
+using testing::StringMatchResultListener;
+
+namespace v8 {
+namespace internal {
+namespace wasm {
+
+#define B1(a) kExprBlock, a, kExprEnd
+#define B2(a, b) kExprBlock, a, b, kExprEnd
+#define B3(a, b, c) kExprBlock, a, b, c, kExprEnd
+
+struct ExpectedTarget {
+ pc_t pc;
+ ControlTransfer expected;
+};
+
+// For nicer error messages.
+class ControlTransferMatcher : public MatcherInterface<const ControlTransfer&> {
+ public:
+ explicit ControlTransferMatcher(pc_t pc, const ControlTransfer& expected)
+ : pc_(pc), expected_(expected) {}
+
+ void DescribeTo(std::ostream* os) const override {
+ *os << "@" << pc_ << " {pcdiff = " << expected_.pcdiff
+ << ", spdiff = " << expected_.spdiff
+ << ", action = " << expected_.action << "}";
+ }
+
+ bool MatchAndExplain(const ControlTransfer& input,
+ MatchResultListener* listener) const override {
+ if (input.pcdiff != expected_.pcdiff || input.spdiff != expected_.spdiff ||
+ input.action != expected_.action) {
+ *listener << "@" << pc_ << " {pcdiff = " << input.pcdiff
+ << ", spdiff = " << input.spdiff
+ << ", action = " << input.action << "}";
+ return false;
+ }
+ return true;
+ }
+
+ private:
+ pc_t pc_;
+ const ControlTransfer& expected_;
+};
+
+class ControlTransferTest : public TestWithZone {
+ public:
+ void CheckControlTransfers(const byte* start, const byte* end,
+ ExpectedTarget* expected_targets,
+ size_t num_targets) {
+ ControlTransferMap map =
+ WasmInterpreter::ComputeControlTransfersForTesting(zone(), start, end);
+ // Check all control targets in the map.
+ for (size_t i = 0; i < num_targets; i++) {
+ pc_t pc = expected_targets[i].pc;
+ auto it = map.find(pc);
+ if (it == map.end()) {
+ printf("expected control target @ +%zu\n", pc);
+ EXPECT_TRUE(false);
+ } else {
+ ControlTransfer& expected = expected_targets[i].expected;
+ ControlTransfer& target = it->second;
+ EXPECT_THAT(target,
+ MakeMatcher(new ControlTransferMatcher(pc, expected)));
+ }
+ }
+
+ // Check there are no other control targets.
+ for (pc_t pc = 0; start + pc < end; pc++) {
+ bool found = false;
+ for (size_t i = 0; i < num_targets; i++) {
+ if (expected_targets[i].pc == pc) {
+ found = true;
+ break;
+ }
+ }
+ if (found) continue;
+ if (map.find(pc) != map.end()) {
+ printf("expected no control @ +%zu\n", pc);
+ EXPECT_TRUE(false);
+ }
+ }
+ }
+};
+
+// Macro for simplifying tests below.
+#define EXPECT_TARGETS(...) \
+ do { \
+ ExpectedTarget pairs[] = {__VA_ARGS__}; \
+ CheckControlTransfers(code, code + sizeof(code), pairs, arraysize(pairs)); \
+ } while (false)
+
+TEST_F(ControlTransferTest, SimpleIf) {
+ byte code[] = {
+ kExprI32Const, // @0
+ 0, // +1
+ kExprIf, // @2
+ kExprEnd // @3
+ };
+ EXPECT_TARGETS({2, {2, 0, ControlTransfer::kPushVoid}}, // --
+ {3, {1, 0, ControlTransfer::kPushVoid}});
+}
+
+TEST_F(ControlTransferTest, SimpleIf1) {
+ byte code[] = {
+ kExprI32Const, // @0
+ 0, // +1
+ kExprIf, // @2
+ kExprNop, // @3
+ kExprEnd // @4
+ };
+ EXPECT_TARGETS({2, {3, 0, ControlTransfer::kPushVoid}}, // --
+ {4, {1, 1, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, SimpleIf2) {
+ byte code[] = {
+ kExprI32Const, // @0
+ 0, // +1
+ kExprIf, // @2
+ kExprNop, // @3
+ kExprNop, // @4
+ kExprEnd // @5
+ };
+ EXPECT_TARGETS({2, {4, 0, ControlTransfer::kPushVoid}}, // --
+ {5, {1, 2, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, SimpleIfElse) {
+ byte code[] = {
+ kExprI32Const, // @0
+ 0, // +1
+ kExprIf, // @2
+ kExprElse, // @3
+ kExprEnd // @4
+ };
+ EXPECT_TARGETS({2, {2, 0, ControlTransfer::kNoAction}}, // --
+ {3, {2, 0, ControlTransfer::kPushVoid}}, // --
+ {4, {1, 0, ControlTransfer::kPushVoid}});
+}
+
+TEST_F(ControlTransferTest, SimpleIfElse1) {
+ byte code[] = {
+ kExprI32Const, // @0
+ 0, // +1
+ kExprIf, // @2
+ kExprNop, // @3
+ kExprElse, // @4
+ kExprNop, // @5
+ kExprEnd // @6
+ };
+ EXPECT_TARGETS({2, {3, 0, ControlTransfer::kNoAction}}, // --
+ {4, {3, 1, ControlTransfer::kPopAndRepush}}, // --
+ {6, {1, 1, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, IfBr) {
+ byte code[] = {
+ kExprI32Const, // @0
+ 0, // +1
+ kExprIf, // @2
+ kExprBr, // @3
+ ARITY_0, // +1
+ 0, // +1
+ kExprEnd // @6
+ };
+ EXPECT_TARGETS({2, {5, 0, ControlTransfer::kPushVoid}}, // --
+ {3, {4, 0, ControlTransfer::kPushVoid}}, // --
+ {6, {1, 1, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, IfBrElse) {
+ byte code[] = {
+ kExprI32Const, // @0
+ 0, // +1
+ kExprIf, // @2
+ kExprBr, // @3
+ ARITY_0, // +1
+ 0, // +1
+ kExprElse, // @6
+ kExprEnd // @7
+ };
+ EXPECT_TARGETS({2, {5, 0, ControlTransfer::kNoAction}}, // --
+ {3, {5, 0, ControlTransfer::kPushVoid}}, // --
+ {6, {2, 1, ControlTransfer::kPopAndRepush}}, // --
+ {7, {1, 0, ControlTransfer::kPushVoid}});
+}
+
+TEST_F(ControlTransferTest, IfElseBr) {
+ byte code[] = {
+ kExprI32Const, // @0
+ 0, // +1
+ kExprIf, // @2
+ kExprNop, // @3
+ kExprElse, // @4
+ kExprBr, // @5
+ ARITY_0, // +1
+ 0, // +1
+ kExprEnd // @8
+ };
+ EXPECT_TARGETS({2, {3, 0, ControlTransfer::kNoAction}}, // --
+ {4, {5, 1, ControlTransfer::kPopAndRepush}}, // --
+ {5, {4, 0, ControlTransfer::kPushVoid}}, // --
+ {8, {1, 1, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, BlockEmpty) {
+ byte code[] = {
+ kExprBlock, // @0
+ kExprEnd // @1
+ };
+ EXPECT_TARGETS({1, {1, 0, ControlTransfer::kPushVoid}});
+}
+
+TEST_F(ControlTransferTest, Br0) {
+ byte code[] = {
+ kExprBlock, // @0
+ kExprBr, // @1
+ ARITY_0, // +1
+ 0, // +1
+ kExprEnd // @4
+ };
+ EXPECT_TARGETS({1, {4, 0, ControlTransfer::kPushVoid}},
+ {4, {1, 1, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, Br1) {
+ byte code[] = {
+ kExprBlock, // @0
+ kExprNop, // @1
+ kExprBr, // @2
+ ARITY_0, // +1
+ 0, // +1
+ kExprEnd // @5
+ };
+ EXPECT_TARGETS({2, {4, 1, ControlTransfer::kPopAndRepush}}, // --
+ {5, {1, 2, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, Br2) {
+ byte code[] = {
+ kExprBlock, // @0
+ kExprNop, // @1
+ kExprNop, // @2
+ kExprBr, // @3
+ ARITY_0, // +1
+ 0, // +1
+ kExprEnd // @6
+ };
+ EXPECT_TARGETS({3, {4, 2, ControlTransfer::kPopAndRepush}}, // --
+ {6, {1, 3, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, Br0b) {
+ byte code[] = {
+ kExprBlock, // @0
+ kExprBr, // @1
+ ARITY_0, // +1
+ 0, // +1
+ kExprNop, // @4
+ kExprEnd // @5
+ };
+ EXPECT_TARGETS({1, {5, 0, ControlTransfer::kPushVoid}}, // --
+ {5, {1, 2, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, Br0c) {
+ byte code[] = {
+ kExprBlock, // @0
+ kExprBr, // @1
+ ARITY_0, // +1
+ 0, // +1
+ kExprNop, // @4
+ kExprNop, // @5
+ kExprEnd // @6
+ };
+ EXPECT_TARGETS({1, {6, 0, ControlTransfer::kPushVoid}}, // --
+ {6, {1, 3, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, SimpleLoop1) {
+ byte code[] = {
+ kExprLoop, // @0
+ kExprBr, // @1
+ ARITY_0, // +1
+ 0, // +1
+ kExprEnd // @4
+ };
+ EXPECT_TARGETS({1, {-1, 0, ControlTransfer::kNoAction}}, // --
+ {4, {1, 1, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, SimpleLoop2) {
+ byte code[] = {
+ kExprLoop, // @0
+ kExprNop, // @1
+ kExprBr, // @2
+ ARITY_0, // +1
+ 0, // +1
+ kExprEnd // @5
+ };
+ EXPECT_TARGETS({2, {-2, 1, ControlTransfer::kNoAction}}, // --
+ {5, {1, 2, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, SimpleLoopExit1) {
+ byte code[] = {
+ kExprLoop, // @0
+ kExprBr, // @1
+ ARITY_0, // +1
+ 1, // +1
+ kExprEnd // @4
+ };
+ EXPECT_TARGETS({1, {4, 0, ControlTransfer::kPushVoid}}, // --
+ {4, {1, 1, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, SimpleLoopExit2) {
+ byte code[] = {
+ kExprLoop, // @0
+ kExprNop, // @1
+ kExprBr, // @2
+ ARITY_0, // +1
+ 1, // +1
+ kExprEnd // @5
+ };
+ EXPECT_TARGETS({2, {4, 1, ControlTransfer::kPopAndRepush}}, // --
+ {5, {1, 2, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, BrTable0) {
+ byte code[] = {
+ kExprBlock, // @0
+ kExprI8Const, // @1
+ 0, // +1
+ kExprBrTable, // @3
+ ARITY_0, // +1
+ 0, // +1
+ U32_LE(0), // +4
+ kExprEnd // @10
+ };
+ EXPECT_TARGETS({3, {8, 0, ControlTransfer::kPushVoid}}, // --
+ {10, {1, 1, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, BrTable1) {
+ byte code[] = {
+ kExprBlock, // @0
+ kExprI8Const, // @1
+ 0, // +1
+ kExprBrTable, // @3
+ ARITY_0, // +1
+ 1, // +1
+ U32_LE(0), // +4
+ U32_LE(0), // +4
+ kExprEnd // @14
+ };
+ EXPECT_TARGETS({3, {12, 0, ControlTransfer::kPushVoid}}, // --
+ {4, {11, 0, ControlTransfer::kPushVoid}}, // --
+ {14, {1, 1, ControlTransfer::kPopAndRepush}});
+}
+
+TEST_F(ControlTransferTest, BrTable2) {
+ byte code[] = {
+ kExprBlock, // @0
+ kExprBlock, // @1
+ kExprI8Const, // @2
+ 0, // +1
+ kExprBrTable, // @4
+ ARITY_0, // +1
+ 2, // +1
+ U32_LE(0), // +4
+ U32_LE(0), // +4
+ U32_LE(1), // +4
+ kExprEnd, // @19
+ kExprEnd // @19
+ };
+ EXPECT_TARGETS({4, {16, 0, ControlTransfer::kPushVoid}}, // --
+ {5, {15, 0, ControlTransfer::kPushVoid}}, // --
+ {6, {15, 0, ControlTransfer::kPushVoid}}, // --
+ {19, {1, 1, ControlTransfer::kPopAndRepush}}, // --
+ {20, {1, 1, ControlTransfer::kPopAndRepush}});
+}
+
+} // namespace wasm
+} // namespace internal
+} // namespace v8
diff --git a/test/unittests/wasm/decoder-unittest.cc b/test/unittests/wasm/decoder-unittest.cc
index 11d68f1..e298f0b 100644
--- a/test/unittests/wasm/decoder-unittest.cc
+++ b/test/unittests/wasm/decoder-unittest.cc
@@ -4,6 +4,7 @@
#include "test/unittests/test-utils.h"
+#include "src/objects-inl.h"
#include "src/wasm/decoder.h"
#include "src/wasm/wasm-macro-gen.h"
@@ -22,7 +23,7 @@
do { \
const byte data[] = {__VA_ARGS__}; \
decoder.Reset(data, data + sizeof(data)); \
- int length; \
+ unsigned length; \
EXPECT_EQ(expected, \
decoder.checked_read_u32v(decoder.start(), 0, &length)); \
EXPECT_EQ(expected_length, length); \
@@ -32,7 +33,7 @@
do { \
const byte data[] = {__VA_ARGS__}; \
decoder.Reset(data, data + sizeof(data)); \
- int length; \
+ unsigned length; \
EXPECT_EQ(expected, \
decoder.checked_read_i32v(decoder.start(), 0, &length)); \
EXPECT_EQ(expected_length, length); \
@@ -42,7 +43,7 @@
do { \
const byte data[] = {__VA_ARGS__}; \
decoder.Reset(data, data + sizeof(data)); \
- int length; \
+ unsigned length; \
EXPECT_EQ(expected, \
decoder.checked_read_u64v(decoder.start(), 0, &length)); \
EXPECT_EQ(expected_length, length); \
@@ -52,7 +53,7 @@
do { \
const byte data[] = {__VA_ARGS__}; \
decoder.Reset(data, data + sizeof(data)); \
- int length; \
+ unsigned length; \
EXPECT_EQ(expected, \
decoder.checked_read_i64v(decoder.start(), 0, &length)); \
EXPECT_EQ(expected_length, length); \
@@ -365,7 +366,7 @@
TEST_F(DecoderTest, ReadU32v_off_end1) {
static const byte data[] = {U32V_1(11)};
- int length = 0;
+ unsigned length = 0;
decoder.Reset(data, data);
decoder.checked_read_u32v(decoder.start(), 0, &length);
EXPECT_EQ(0, length);
@@ -375,7 +376,7 @@
TEST_F(DecoderTest, ReadU32v_off_end2) {
static const byte data[] = {U32V_2(1111)};
for (size_t i = 0; i < sizeof(data); i++) {
- int length = 0;
+ unsigned length = 0;
decoder.Reset(data, data + i);
decoder.checked_read_u32v(decoder.start(), 0, &length);
EXPECT_EQ(i, length);
@@ -386,7 +387,7 @@
TEST_F(DecoderTest, ReadU32v_off_end3) {
static const byte data[] = {U32V_3(111111)};
for (size_t i = 0; i < sizeof(data); i++) {
- int length = 0;
+ unsigned length = 0;
decoder.Reset(data, data + i);
decoder.checked_read_u32v(decoder.start(), 0, &length);
EXPECT_EQ(i, length);
@@ -397,7 +398,7 @@
TEST_F(DecoderTest, ReadU32v_off_end4) {
static const byte data[] = {U32V_4(11111111)};
for (size_t i = 0; i < sizeof(data); i++) {
- int length = 0;
+ unsigned length = 0;
decoder.Reset(data, data + i);
decoder.checked_read_u32v(decoder.start(), 0, &length);
EXPECT_EQ(i, length);
@@ -408,7 +409,7 @@
TEST_F(DecoderTest, ReadU32v_off_end5) {
static const byte data[] = {U32V_5(111111111)};
for (size_t i = 0; i < sizeof(data); i++) {
- int length = 0;
+ unsigned length = 0;
decoder.Reset(data, data + i);
decoder.checked_read_u32v(decoder.start(), 0, &length);
EXPECT_EQ(i, length);
@@ -420,7 +421,7 @@
byte data[] = {0x80, 0x80, 0x80, 0x80, 0x00};
for (int i = 1; i < 16; i++) {
data[4] = static_cast<byte>(i << 4);
- int length = 0;
+ unsigned length = 0;
decoder.Reset(data, data + sizeof(data));
decoder.checked_read_u32v(decoder.start(), 0, &length);
EXPECT_EQ(5, length);
@@ -430,7 +431,7 @@
TEST_F(DecoderTest, ReadI32v_extra_bits_negative) {
// OK for negative signed values to have extra ones.
- int length = 0;
+ unsigned length = 0;
byte data[] = {0xff, 0xff, 0xff, 0xff, 0x7f};
decoder.Reset(data, data + sizeof(data));
decoder.checked_read_i32v(decoder.start(), 0, &length);
@@ -440,7 +441,7 @@
TEST_F(DecoderTest, ReadI32v_extra_bits_positive) {
// Not OK for positive signed values to have extra ones.
- int length = 0;
+ unsigned length = 0;
byte data[] = {0x80, 0x80, 0x80, 0x80, 0x77};
decoder.Reset(data, data + sizeof(data));
decoder.checked_read_i32v(decoder.start(), 0, &length);
@@ -477,7 +478,7 @@
// foreach buffer size 0...5
for (int limit = 0; limit <= kMaxSize; limit++) {
decoder.Reset(data, data + limit);
- int rlen;
+ unsigned rlen;
uint32_t result = decoder.checked_read_u32v(data, 0, &rlen);
if (limit < length) {
EXPECT_FALSE(decoder.ok());
@@ -533,7 +534,7 @@
for (int limit = 0; limit <= kMaxSize; limit++) {
decoder.Reset(data, data + limit);
- int length;
+ unsigned length;
uint64_t result = decoder.checked_read_u64v(data, 0, &length);
if (limit <= index) {
EXPECT_FALSE(decoder.ok());
@@ -574,7 +575,7 @@
// foreach buffer size 0...10
for (int limit = 0; limit <= kMaxSize; limit++) {
decoder.Reset(data, data + limit);
- int rlen;
+ unsigned rlen;
uint64_t result = decoder.checked_read_u64v(data, 0, &rlen);
if (limit < length) {
EXPECT_FALSE(decoder.ok());
@@ -616,7 +617,7 @@
// foreach buffer size 0...10
for (int limit = 0; limit <= kMaxSize; limit++) {
decoder.Reset(data, data + limit);
- int rlen;
+ unsigned rlen;
int64_t result = decoder.checked_read_i64v(data, 0, &rlen);
if (limit < length) {
EXPECT_FALSE(decoder.ok());
@@ -634,7 +635,7 @@
byte data[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00};
for (int i = 1; i < 128; i++) {
data[9] = static_cast<byte>(i << 1);
- int length = 0;
+ unsigned length = 0;
decoder.Reset(data, data + sizeof(data));
decoder.checked_read_u64v(decoder.start(), 0, &length);
EXPECT_EQ(10, length);
@@ -644,7 +645,7 @@
TEST_F(DecoderTest, ReadI64v_extra_bits_negative) {
// OK for negative signed values to have extra ones.
- int length = 0;
+ unsigned length = 0;
byte data[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f};
decoder.Reset(data, data + sizeof(data));
decoder.checked_read_i64v(decoder.start(), 0, &length);
@@ -654,7 +655,7 @@
TEST_F(DecoderTest, ReadI64v_extra_bits_positive) {
// Not OK for positive signed values to have extra ones.
- int length = 0;
+ unsigned length = 0;
byte data[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x77};
decoder.Reset(data, data + sizeof(data));
decoder.checked_read_i64v(decoder.start(), 0, &length);
diff --git a/test/unittests/wasm/leb-helper-unittest.cc b/test/unittests/wasm/leb-helper-unittest.cc
index ed9f0a3..b975933 100644
--- a/test/unittests/wasm/leb-helper-unittest.cc
+++ b/test/unittests/wasm/leb-helper-unittest.cc
@@ -4,6 +4,7 @@
#include "test/unittests/test-utils.h"
+#include "src/objects-inl.h"
#include "src/wasm/decoder.h"
#include "src/wasm/leb-helper.h"
@@ -96,7 +97,7 @@
EXPECT_EQ(LEBHelper::sizeof_##name(val), \
static_cast<size_t>(ptr - buffer)); \
Decoder decoder(buffer, buffer + kSize); \
- int length = 0; \
+ unsigned length = 0; \
ctype result = decoder.checked_read_##name(buffer, 0, &length); \
EXPECT_EQ(val, result); \
EXPECT_EQ(LEBHelper::sizeof_##name(val), static_cast<size_t>(length)); \
diff --git a/test/unittests/wasm/loop-assignment-analysis-unittest.cc b/test/unittests/wasm/loop-assignment-analysis-unittest.cc
index 7d97c50..c134de8 100644
--- a/test/unittests/wasm/loop-assignment-analysis-unittest.cc
+++ b/test/unittests/wasm/loop-assignment-analysis-unittest.cc
@@ -180,6 +180,14 @@
}
}
+TEST_F(WasmLoopAssignmentAnalyzerTest, Malformed) {
+ byte code[] = {kExprLoop, kExprF32Neg, kExprBrTable, 0x0e, 'h', 'e',
+ 'l', 'l', 'o', ',', ' ', 'w',
+ 'o', 'r', 'l', 'd', '!'};
+ BitVector* assigned = Analyze(code, code + arraysize(code));
+ CHECK_NULL(assigned);
+}
+
} // namespace wasm
} // namespace internal
} // namespace v8
diff --git a/test/unittests/wasm/module-decoder-unittest.cc b/test/unittests/wasm/module-decoder-unittest.cc
index 7090c1f..789112a 100644
--- a/test/unittests/wasm/module-decoder-unittest.cc
+++ b/test/unittests/wasm/module-decoder-unittest.cc
@@ -4,6 +4,8 @@
#include "test/unittests/test-utils.h"
+#include "src/handles.h"
+#include "src/objects-inl.h"
#include "src/wasm/module-decoder.h"
#include "src/wasm/wasm-macro-gen.h"
#include "src/wasm/wasm-opcodes.h"
@@ -39,6 +41,38 @@
#define EMPTY_FUNCTION_BODIES_SECTION SECTION(FUNCTION_BODIES, 1), 0
#define EMPTY_NAMES_SECTION SECTION(NAMES, 1), 0
+#define X1(...) __VA_ARGS__
+#define X2(...) __VA_ARGS__, __VA_ARGS__
+#define X3(...) __VA_ARGS__, __VA_ARGS__, __VA_ARGS__
+#define X4(...) __VA_ARGS__, __VA_ARGS__, __VA_ARGS__, __VA_ARGS__
+
+#define ONE_EMPTY_FUNCTION WASM_SECTION_FUNCTION_SIGNATURES, 1 + 1 * 1, 1, X1(0)
+
+#define TWO_EMPTY_FUNCTIONS \
+ WASM_SECTION_FUNCTION_SIGNATURES, 1 + 2 * 1, 2, X2(0)
+
+#define THREE_EMPTY_FUNCTIONS \
+ WASM_SECTION_FUNCTION_SIGNATURES, 1 + 3 * 1, 3, X3(0)
+
+#define FOUR_EMPTY_FUNCTIONS \
+ WASM_SECTION_FUNCTION_SIGNATURES, 1 + 4 * 1, 4, X4(0)
+
+#define ONE_EMPTY_BODY \
+ WASM_SECTION_FUNCTION_BODIES, 1 + 1 * (1 + SIZEOF_EMPTY_BODY), 1, \
+ X1(SIZEOF_EMPTY_BODY, EMPTY_BODY)
+
+#define TWO_EMPTY_BODIES \
+ WASM_SECTION_FUNCTION_BODIES, 1 + 2 * (1 + SIZEOF_EMPTY_BODY), 2, \
+ X2(SIZEOF_EMPTY_BODY, EMPTY_BODY)
+
+#define THREE_EMPTY_BODIES \
+ WASM_SECTION_FUNCTION_BODIES, 1 + 3 * (1 + SIZEOF_EMPTY_BODY), 3, \
+ X3(SIZEOF_EMPTY_BODY, EMPTY_BODY)
+
+#define FOUR_EMPTY_BODIES \
+ WASM_SECTION_FUNCTION_BODIES, 1 + 4 * (1 + SIZEOF_EMPTY_BODY), 4, \
+ X4(SIZEOF_EMPTY_BODY, EMPTY_BODY)
+
#define SIGNATURES_SECTION_VOID_VOID \
SECTION(SIGNATURES, 1 + SIZEOF_SIG_ENTRY_v_v), 1, SIG_ENTRY_v_v
@@ -156,7 +190,7 @@
EXPECT_EQ(0, result.val->functions.size());
EXPECT_EQ(0, result.val->data_segments.size());
- WasmGlobal* global = &result.val->globals.back();
+ const WasmGlobal* global = &result.val->globals.back();
EXPECT_EQ(1, global->name_length);
EXPECT_EQ(MachineType::Int32(), global->type);
@@ -169,6 +203,21 @@
EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
}
+TEST_F(WasmModuleVerifyTest, Global_invalid_type) {
+ static const byte data[] = {
+ SECTION(GLOBALS, 5), // --
+ 1,
+ NAME_LENGTH(1),
+ 'g', // name
+ 64, // invalid memory type
+ 0, // exported
+ };
+
+ ModuleResult result = DecodeModuleNoHeader(data, data + sizeof(data));
+ EXPECT_FALSE(result.ok());
+ if (result.val) delete result.val;
+}
+
TEST_F(WasmModuleVerifyTest, ZeroGlobals) {
static const byte data[] = {
SECTION(GLOBALS, 1), // --
@@ -262,8 +311,8 @@
EXPECT_EQ(0, result.val->functions.size());
EXPECT_EQ(0, result.val->data_segments.size());
- WasmGlobal* g0 = &result.val->globals[0];
- WasmGlobal* g1 = &result.val->globals[1];
+ const WasmGlobal* g0 = &result.val->globals[0];
+ const WasmGlobal* g1 = &result.val->globals[1];
EXPECT_EQ(0, g0->name_length);
EXPECT_EQ(MachineType::Float32(), g0->type);
@@ -272,7 +321,7 @@
EXPECT_EQ(0, g1->name_length);
EXPECT_EQ(MachineType::Float64(), g1->type);
- EXPECT_EQ(0, g1->offset);
+ EXPECT_EQ(8, g1->offset);
EXPECT_TRUE(g1->exported);
if (result.val) delete result.val;
@@ -321,163 +370,6 @@
EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
}
-TEST_F(WasmModuleVerifyTest, FunctionWithoutSig) {
- static const byte data[] = {
- SECTION(OLD_FUNCTIONS, 25), 1,
- // func#0 ------------------------------------------------------
- SIG_INDEX(0), // signature index
- NO_NAME, // name length
- U32_LE(0), // code start offset
- U32_LE(0), // code end offset
- U16_LE(899), // local int32 count
- U16_LE(799), // local int64 count
- U16_LE(699), // local float32 count
- U16_LE(599), // local float64 count
- 0, // exported
- 0 // external
- };
-
- ModuleResult result = DecodeModule(data, data + arraysize(data));
- EXPECT_FALSE(result.ok());
- if (result.val) delete result.val;
-}
-
-TEST_F(WasmModuleVerifyTest, OneEmptyVoidVoidFunction) {
- const int kCodeStartOffset = 41;
- const int kCodeEndOffset = kCodeStartOffset + 1;
-
- static const byte data[] = {
- // signatures
- SIGNATURES_SECTION_VOID_VOID,
- // func#0 ------------------------------------------------------
- SECTION(OLD_FUNCTIONS, 10), 1, kDeclFunctionExport | kDeclFunctionName,
- SIG_INDEX(0), // signature index
- NAME_LENGTH(2), 'h', 'i', // name
- 1, 0, // size
- kExprNop,
- };
-
- {
- // Should decode to exactly one function.
- ModuleResult result = DecodeModule(data, data + arraysize(data));
- EXPECT_OK(result);
- EXPECT_EQ(0, result.val->globals.size());
- EXPECT_EQ(1, result.val->signatures.size());
- EXPECT_EQ(1, result.val->functions.size());
- EXPECT_EQ(0, result.val->data_segments.size());
- EXPECT_EQ(0, result.val->function_table.size());
-
- WasmFunction* function = &result.val->functions.back();
-
- EXPECT_EQ(37, function->name_offset);
- EXPECT_EQ(2, function->name_length);
- EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
- EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
-
- EXPECT_TRUE(function->exported);
-
- if (result.val) delete result.val;
- }
-
- EXPECT_OFF_END_FAILURE(data, 16, sizeof(data));
-}
-
-TEST_F(WasmModuleVerifyTest, OneFunctionWithNopBody) {
- static const byte kCodeStartOffset = 38;
- static const byte kCodeEndOffset = kCodeStartOffset + 1;
-
- static const byte data[] = {
- SIGNATURES_SECTION_VOID_VOID, // --
- SECTION(OLD_FUNCTIONS, 7), 1,
- // func#0 ------------------------------------------------------
- 0, // no name, no locals
- 0, 0, // signature index
- 1, 0, // body size
- kExprNop // body
- };
-
- ModuleResult result = DecodeModule(data, data + arraysize(data));
- EXPECT_OK(result);
- EXPECT_EQ(1, result.val->functions.size());
- WasmFunction* function = &result.val->functions.back();
-
- EXPECT_EQ(0, function->name_length);
- EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
- EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
-
- EXPECT_FALSE(function->exported);
-
- if (result.val) delete result.val;
-}
-
-TEST_F(WasmModuleVerifyTest, OneGlobalOneFunctionWithNopBodyOneDataSegment) {
- static const byte kNameOffset = 49;
- static const byte kCodeStartOffset = 53;
- static const byte kCodeEndOffset = kCodeStartOffset + 3;
- static const byte kDataSegmentSourceOffset = kCodeEndOffset + 22;
-
- static const byte data[] = {
- // global#0 --------------------------------------------------
- SECTION(GLOBALS, 4), 1,
- 0, // name length
- kMemU8, // memory type
- 0, // exported
- // sig#0 -----------------------------------------------------
- SIGNATURES_SECTION_VOID_VOID,
- // func#0 ----------------------------------------------------
- SECTION(OLD_FUNCTIONS, 12), 1,
- kDeclFunctionName, // --
- SIG_INDEX(0), // signature index
- 2, 'h', 'i', // name
- 3, 0, // body size
- kExprNop, // func#0 body
- kExprNop, // func#0 body
- kExprNop, // func#0 body
- // memory section --------------------------------------------
- SECTION(MEMORY, 3), 28, 28, 1,
- // segment#0 -------------------------------------------------
- SECTION(DATA_SEGMENTS, 10), 1,
- U32V_3(0x8b3ae), // dest addr
- U32V_1(5), // source size
- 0, 1, 2, 3, 4, // data bytes
- // rest ------------------------------------------------------
- SECTION(END, 0),
- };
-
- {
- ModuleResult result = DecodeModule(data, data + arraysize(data));
- EXPECT_OK(result);
- EXPECT_EQ(1, result.val->globals.size());
- EXPECT_EQ(1, result.val->functions.size());
- EXPECT_EQ(1, result.val->data_segments.size());
-
- WasmGlobal* global = &result.val->globals.back();
-
- EXPECT_EQ(0, global->name_length);
- EXPECT_EQ(MachineType::Uint8(), global->type);
- EXPECT_EQ(0, global->offset);
- EXPECT_FALSE(global->exported);
-
- WasmFunction* function = &result.val->functions.back();
-
- EXPECT_EQ(kNameOffset, function->name_offset);
- EXPECT_EQ(2, function->name_length);
- EXPECT_EQ(kCodeStartOffset, function->code_start_offset);
- EXPECT_EQ(kCodeEndOffset, function->code_end_offset);
-
- EXPECT_FALSE(function->exported);
-
- WasmDataSegment* segment = &result.val->data_segments.back();
-
- EXPECT_EQ(0x8b3ae, segment->dest_addr);
- EXPECT_EQ(kDataSegmentSourceOffset, segment->source_offset);
- EXPECT_EQ(5, segment->source_size);
- EXPECT_TRUE(segment->init);
-
- if (result.val) delete result.val;
- }
-}
-
TEST_F(WasmModuleVerifyTest, OneDataSegment) {
const byte kDataSegmentSourceOffset = 30;
const byte data[] = {
@@ -502,7 +394,7 @@
EXPECT_EQ(0, result.val->functions.size());
EXPECT_EQ(1, result.val->data_segments.size());
- WasmDataSegment* segment = &result.val->data_segments.back();
+ const WasmDataSegment* segment = &result.val->data_segments.back();
EXPECT_EQ(0x9bbaa, segment->dest_addr);
EXPECT_EQ(kDataSegmentSourceOffset, segment->source_offset);
@@ -553,8 +445,8 @@
EXPECT_EQ(0, result.val->functions.size());
EXPECT_EQ(2, result.val->data_segments.size());
- WasmDataSegment* s0 = &result.val->data_segments[0];
- WasmDataSegment* s1 = &result.val->data_segments[1];
+ const WasmDataSegment* s0 = &result.val->data_segments[0];
+ const WasmDataSegment* s1 = &result.val->data_segments[1];
EXPECT_EQ(0x7ffee, s0->dest_addr);
EXPECT_EQ(kDataSegment0SourceOffset, s0->source_offset);
@@ -605,9 +497,8 @@
static const byte data[] = {
// sig#0 -------------------------------------------------------
SIGNATURES_SECTION_VOID_VOID,
- // func#0 ------------------------------------------------------
- SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION), 1, // --
- EMPTY_FUNCTION(0),
+ // funcs ------------------------------------------------------
+ ONE_EMPTY_FUNCTION,
// indirect table ----------------------------------------------
SECTION(FUNCTION_TABLE, 2), 1, U32V_1(0)};
@@ -629,12 +520,8 @@
2, // --
SIG_ENTRY_v_v, // void -> void
SIG_ENTRY_v_x(kLocalI32), // void -> i32
- // func#0 ------------------------------------------------------
- SECTION(OLD_FUNCTIONS, 1 + 4 * SIZEOF_EMPTY_FUNCTION), 4, // --
- EMPTY_FUNCTION(0), // --
- EMPTY_FUNCTION(1), // --
- EMPTY_FUNCTION(0), // --
- EMPTY_FUNCTION(1), // --
+ // funcs ------------------------------------------------------
+ FOUR_EMPTY_FUNCTIONS,
// indirect table ----------------------------------------------
SECTION(FUNCTION_TABLE, 9), 8,
U32V_1(0), // --
@@ -645,7 +532,7 @@
U32V_1(1), // --
U32V_1(2), // --
U32V_1(3), // --
- };
+ FOUR_EMPTY_BODIES};
ModuleResult result = DecodeModule(data, data + arraysize(data));
EXPECT_OK(result);
@@ -676,8 +563,7 @@
// sig#0 -------------------------------------------------------
SIGNATURES_SECTION_VOID_VOID,
// functions ---------------------------------------------------
- SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION), 1, // --
- EMPTY_FUNCTION(0),
+ ONE_EMPTY_FUNCTION,
// indirect table ----------------------------------------------
SECTION(FUNCTION_TABLE, 3), 1, 1, 0,
};
@@ -839,7 +725,6 @@
EXPECT_EQ(SIZEOF_SIG_ENTRY_v_v, function->code_start_offset);
EXPECT_EQ(arraysize(data), function->code_end_offset);
// TODO(titzer): verify encoding of local declarations
- EXPECT_FALSE(function->exported);
}
if (result.val) delete result.val;
@@ -983,7 +868,7 @@
EXPECT_EQ(0, result.val->functions.size());
EXPECT_EQ(0, result.val->data_segments.size());
- WasmGlobal* global = &result.val->globals.back();
+ const WasmGlobal* global = &result.val->globals.back();
EXPECT_EQ(0, global->name_length);
EXPECT_EQ(MachineType::Int32(), global->type);
@@ -1071,22 +956,24 @@
}
TEST_F(WasmModuleVerifyTest, ExportTable_empty1) {
- static const byte data[] = {
- // signatures
- SIGNATURES_SECTION_VOID_VOID,
- SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
- 1,
- EMPTY_FUNCTION(0),
- SECTION(EXPORT_TABLE, 1),
- 0 // --
- };
- EXPECT_VERIFIES(data);
+ static const byte data[] = {// signatures
+ SIGNATURES_SECTION_VOID_VOID, ONE_EMPTY_FUNCTION,
+ SECTION(EXPORT_TABLE, 1),
+ 0, // --
+ ONE_EMPTY_BODY};
+
+ ModuleResult result = DecodeModule(data, data + arraysize(data));
+ EXPECT_OK(result);
+
+ EXPECT_EQ(1, result.val->functions.size());
+ EXPECT_EQ(0, result.val->export_table.size());
+
+ if (result.val) delete result.val;
}
TEST_F(WasmModuleVerifyTest, ExportTable_empty2) {
static const byte data[] = {
- SECTION(SIGNATURES, 1), 0, SECTION(OLD_FUNCTIONS, 1), 0,
- SECTION(EXPORT_TABLE, 1), 0 // --
+ SECTION(SIGNATURES, 1), 0, SECTION(EXPORT_TABLE, 1), 0 // --
};
// TODO(titzer): current behavior treats empty functions section as missing.
EXPECT_FAILURE(data);
@@ -1105,85 +992,88 @@
}
TEST_F(WasmModuleVerifyTest, ExportTableOne) {
- static const byte data[] = {
- // signatures
- SIGNATURES_SECTION_VOID_VOID,
- SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
- 1, // functions
- EMPTY_FUNCTION(0), // --
- SECTION(EXPORT_TABLE, 3),
- 1, // exports
- FUNC_INDEX(0), // --
- NO_NAME // --
- };
- EXPECT_VERIFIES(data);
+ static const byte data[] = {// signatures
+ SIGNATURES_SECTION_VOID_VOID,
+ ONE_EMPTY_FUNCTION,
+ SECTION(EXPORT_TABLE, 3),
+ 1, // exports
+ FUNC_INDEX(0), // --
+ NO_NAME, // --
+ ONE_EMPTY_BODY};
+ ModuleResult result = DecodeModule(data, data + arraysize(data));
+ EXPECT_OK(result);
+
+ EXPECT_EQ(1, result.val->functions.size());
+ EXPECT_EQ(1, result.val->export_table.size());
+
+ if (result.val) delete result.val;
}
TEST_F(WasmModuleVerifyTest, ExportTableTwo) {
- static const byte data[] = {
- // signatures
- SIGNATURES_SECTION_VOID_VOID,
- SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
- 1, // functions
- EMPTY_FUNCTION(0), // --
- SECTION(EXPORT_TABLE, 12),
- 2, // exports
- FUNC_INDEX(0), // --
- NAME_LENGTH(4),
- 'n',
- 'a',
- 'm',
- 'e', // --
- FUNC_INDEX(0), // --
- NAME_LENGTH(3),
- 'n',
- 'o',
- 'm' // --
- };
- EXPECT_VERIFIES(data);
+ static const byte data[] = {// signatures
+ SIGNATURES_SECTION_VOID_VOID,
+ ONE_EMPTY_FUNCTION,
+ SECTION(EXPORT_TABLE, 12),
+ 2, // exports
+ FUNC_INDEX(0), // --
+ NAME_LENGTH(4),
+ 'n',
+ 'a',
+ 'm',
+ 'e', // --
+ FUNC_INDEX(0), // --
+ NAME_LENGTH(3),
+ 'n',
+ 'o',
+ 'm', // --
+ ONE_EMPTY_BODY};
+
+ ModuleResult result = DecodeModule(data, data + arraysize(data));
+ EXPECT_OK(result);
+
+ EXPECT_EQ(1, result.val->functions.size());
+ EXPECT_EQ(2, result.val->export_table.size());
+
+ if (result.val) delete result.val;
}
TEST_F(WasmModuleVerifyTest, ExportTableThree) {
- static const byte data[] = {
- // signatures
- SIGNATURES_SECTION_VOID_VOID,
- SECTION(OLD_FUNCTIONS, 1 + 3 * SIZEOF_EMPTY_FUNCTION),
- 3, // functions
- EMPTY_FUNCTION(0), // --
- EMPTY_FUNCTION(0), // --
- EMPTY_FUNCTION(0), // --
- SECTION(EXPORT_TABLE, 10),
- 3, // exports
- FUNC_INDEX(0), // --
- NAME_LENGTH(1),
- 'a', // --
- FUNC_INDEX(1), // --
- NAME_LENGTH(1),
- 'b', // --
- FUNC_INDEX(2), // --
- NAME_LENGTH(1),
- 'c' // --
- };
- EXPECT_VERIFIES(data);
+ static const byte data[] = {// signatures
+ SIGNATURES_SECTION_VOID_VOID,
+ THREE_EMPTY_FUNCTIONS,
+ SECTION(EXPORT_TABLE, 10),
+ 3, // exports
+ FUNC_INDEX(0), // --
+ NAME_LENGTH(1),
+ 'a', // --
+ FUNC_INDEX(1), // --
+ NAME_LENGTH(1),
+ 'b', // --
+ FUNC_INDEX(2), // --
+ NAME_LENGTH(1),
+ 'c', // --
+ THREE_EMPTY_BODIES};
+ ModuleResult result = DecodeModule(data, data + arraysize(data));
+ EXPECT_OK(result);
+
+ EXPECT_EQ(3, result.val->functions.size());
+ EXPECT_EQ(3, result.val->export_table.size());
+
+ if (result.val) delete result.val;
}
TEST_F(WasmModuleVerifyTest, ExportTableThreeOne) {
for (int i = 0; i < 6; i++) {
- const byte data[] = {
- // signatures
- SIGNATURES_SECTION_VOID_VOID,
- SECTION(OLD_FUNCTIONS, 1 + 3 * SIZEOF_EMPTY_FUNCTION),
- 3, // functions
- EMPTY_FUNCTION(0), // --
- EMPTY_FUNCTION(0), // --
- EMPTY_FUNCTION(0), // --
- SECTION(EXPORT_TABLE, 5),
- 1, // exports
- FUNC_INDEX(i), // --
- NAME_LENGTH(2),
- 'e',
- 'x', // --
- };
+ const byte data[] = {// signatures
+ SIGNATURES_SECTION_VOID_VOID,
+ THREE_EMPTY_FUNCTIONS,
+ SECTION(EXPORT_TABLE, 5),
+ 1, // exports
+ FUNC_INDEX(i), // --
+ NAME_LENGTH(2),
+ 'e',
+ 'x', // --
+ THREE_EMPTY_BODIES};
if (i < 3) {
EXPECT_VERIFIES(data);
@@ -1197,9 +1087,7 @@
static const byte data[] = {
// signatures
SIGNATURES_SECTION_VOID_VOID,
- SECTION(OLD_FUNCTIONS, 1 + SIZEOF_EMPTY_FUNCTION),
- 1, // functions
- EMPTY_FUNCTION(0), // --
+ ONE_EMPTY_FUNCTION,
SECTION(EXPORT_TABLE, 1 + 6),
1, // exports
FUNC_INDEX(0), // --
diff --git a/test/webkit/class-syntax-extends-expected.txt b/test/webkit/class-syntax-extends-expected.txt
index 45e999d..5d0dca7 100644
--- a/test/webkit/class-syntax-extends-expected.txt
+++ b/test/webkit/class-syntax-extends-expected.txt
@@ -23,8 +23,8 @@
PASS Object.getPrototypeOf(x.prototype) is Base.prototype
PASS x = class extends null { constructor() { } }; x.__proto__ is Function.prototype
PASS x.__proto__ is Function.prototype
-PASS x = class extends 3 { constructor() { } }; x.__proto__ threw exception TypeError: Class extends value 3 is not a function or null.
-PASS x = class extends "abc" { constructor() { } }; x.__proto__ threw exception TypeError: Class extends value abc is not a function or null.
+PASS x = class extends 3 { constructor() { } }; x.__proto__ threw exception TypeError: Class extends value 3 is not a constructor or null.
+PASS x = class extends "abc" { constructor() { } }; x.__proto__ threw exception TypeError: Class extends value abc is not a constructor or null.
PASS baseWithBadPrototype = function () {}; baseWithBadPrototype.prototype = 3; new baseWithBadPrototype did not throw exception.
PASS x = class extends baseWithBadPrototype { constructor() { } } threw exception TypeError: Class extends value does not have valid prototype property 3.
PASS baseWithBadPrototype.prototype = "abc" did not throw exception.
@@ -32,8 +32,8 @@
PASS baseWithBadPrototype.prototype = null; x = class extends baseWithBadPrototype { constructor() { } } did not throw exception.
PASS x = 1; c = class extends ++x { constructor() { } }; threw exception SyntaxError: Unexpected token ++.
PASS x = 1; c = class extends x++ { constructor() { } }; threw exception SyntaxError: Unexpected token ++.
-PASS x = 1; c = class extends (++x) { constructor() { } }; threw exception TypeError: Class extends value 2 is not a function or null.
-PASS x = 1; c = class extends (x++) { constructor() { } }; threw exception TypeError: Class extends value 1 is not a function or null.
+PASS x = 1; c = class extends (++x) { constructor() { } }; threw exception TypeError: Class extends value 2 is not a constructor or null.
+PASS x = 1; c = class extends (x++) { constructor() { } }; threw exception TypeError: Class extends value 1 is not a constructor or null.
PASS x = 1; try { c = class extends (++x) { constructor() { } } } catch (e) { }; x is 2
PASS x = 1; try { c = class extends (x++) { constructor() { } } } catch (e) { }; x is 2
PASS namespace = {}; namespace.A = class { }; namespace.B = class extends namespace.A { } did not throw exception.
@@ -47,17 +47,17 @@
PASS namespace = {}; namespace.A = class { constructor() { } }; namespace.B = class extends (false||null||namespace.A) { constructor() { } } did not throw exception.
PASS namespace = {}; namespace.A = class { constructor() { } }; namespace.B = class extends false||null||namespace.A { constructor() { } } threw exception SyntaxError: Unexpected token ||.
PASS x = 1; namespace = {}; namespace.A = class { constructor() { } }; namespace.B = class extends (x++, namespace.A) { constructor() { } }; did not throw exception.
-PASS x = 1; namespace = {}; namespace.A = class { constructor() { } }; namespace.B = class extends (namespace.A, x++) { constructor() { } }; threw exception TypeError: Class extends value 1 is not a function or null.
-PASS namespace = {}; namespace.A = class { constructor() { } }; namespace.B = class extends new namespace.A { constructor() { } } threw exception TypeError: Class extends value [object Object] is not a function or null.
-PASS namespace = {}; namespace.A = class { constructor() { } }; namespace.B = class extends new namespace.A() { constructor() { } } threw exception TypeError: Class extends value [object Object] is not a function or null.
+PASS x = 1; namespace = {}; namespace.A = class { constructor() { } }; namespace.B = class extends (namespace.A, x++) { constructor() { } }; threw exception TypeError: Class extends value 1 is not a constructor or null.
+PASS namespace = {}; namespace.A = class { constructor() { } }; namespace.B = class extends new namespace.A { constructor() { } } threw exception TypeError: Class extends value [object Object] is not a constructor or null.
+PASS namespace = {}; namespace.A = class { constructor() { } }; namespace.B = class extends new namespace.A() { constructor() { } } threw exception TypeError: Class extends value [object Object] is not a constructor or null.
PASS x = 1; namespace = {}; namespace.A = class { constructor() { } }; try { namespace.B = class extends (x++, namespace.A) { constructor() { } } } catch (e) { } x is 2
PASS x = 1; namespace = {}; namespace.A = class { constructor() { } }; try { namespace.B = class extends (namespace.A, x++) { constructor() { } } } catch (e) { } x is 2
PASS Object.getPrototypeOf((class { constructor () { } }).prototype) is Object.prototype
PASS Object.getPrototypeOf((class extends null { constructor () { super(); } }).prototype) is null
-PASS new (class extends undefined { constructor () { this } }) threw exception TypeError: Class extends value undefined is not a function or null.
-PASS new (class extends undefined { constructor () { super(); } }) threw exception TypeError: Class extends value undefined is not a function or null.
-PASS x = {}; new (class extends undefined { constructor () { return x; } }) threw exception TypeError: Class extends value undefined is not a function or null.
-PASS y = 12; new (class extends undefined { constructor () { return y; } }) threw exception TypeError: Class extends value undefined is not a function or null.
+PASS new (class extends undefined { constructor () { this } }) threw exception TypeError: Class extends value undefined is not a constructor or null.
+PASS new (class extends undefined { constructor () { super(); } }) threw exception TypeError: Class extends value undefined is not a constructor or null.
+PASS x = {}; new (class extends undefined { constructor () { return x; } }) threw exception TypeError: Class extends value undefined is not a constructor or null.
+PASS y = 12; new (class extends undefined { constructor () { return y; } }) threw exception TypeError: Class extends value undefined is not a constructor or null.
PASS class x {}; new (class extends null { constructor () { return new x; } }) instanceof x is true
PASS new (class extends null { constructor () { this; } }) threw exception ReferenceError: this is not defined.
PASS new (class extends null { constructor () { super(); } }) threw exception TypeError: super is not a constructor.
diff --git a/test/webkit/class-syntax-extends.js b/test/webkit/class-syntax-extends.js
index ccd3f29..d505bf8 100644
--- a/test/webkit/class-syntax-extends.js
+++ b/test/webkit/class-syntax-extends.js
@@ -58,8 +58,8 @@
shouldBe('Object.getPrototypeOf(x.prototype)', 'Base.prototype');
shouldBe('x = class extends null { constructor() { } }; x.__proto__', 'Function.prototype');
shouldBe('x.__proto__', 'Function.prototype');
-shouldThrow('x = class extends 3 { constructor() { } }; x.__proto__', '"TypeError: Class extends value 3 is not a function or null"');
-shouldThrow('x = class extends "abc" { constructor() { } }; x.__proto__', '"TypeError: Class extends value abc is not a function or null"');
+shouldThrow('x = class extends 3 { constructor() { } }; x.__proto__', '"TypeError: Class extends value 3 is not a constructor or null"');
+shouldThrow('x = class extends "abc" { constructor() { } }; x.__proto__', '"TypeError: Class extends value abc is not a constructor or null"');
shouldNotThrow('baseWithBadPrototype = function () {}; baseWithBadPrototype.prototype = 3; new baseWithBadPrototype');
shouldThrow('x = class extends baseWithBadPrototype { constructor() { } }', '"TypeError: Class extends value does not have valid prototype property 3"');
shouldNotThrow('baseWithBadPrototype.prototype = "abc"');
@@ -92,10 +92,10 @@
shouldBe('Object.getPrototypeOf((class { constructor () { } }).prototype)', 'Object.prototype');
shouldBe('Object.getPrototypeOf((class extends null { constructor () { super(); } }).prototype)', 'null');
-shouldThrow('new (class extends undefined { constructor () { this } })', '"TypeError: Class extends value undefined is not a function or null"');
-shouldThrow('new (class extends undefined { constructor () { super(); } })', '"TypeError: Class extends value undefined is not a function or null"');
-shouldThrow('x = {}; new (class extends undefined { constructor () { return x; } })', '"TypeError: Class extends value undefined is not a function or null"');
-shouldThrow('y = 12; new (class extends undefined { constructor () { return y; } })', '"TypeError: Class extends value undefined is not a function or null"');
+shouldThrow('new (class extends undefined { constructor () { this } })', '"TypeError: Class extends value undefined is not a constructor or null"');
+shouldThrow('new (class extends undefined { constructor () { super(); } })', '"TypeError: Class extends value undefined is not a constructor or null"');
+shouldThrow('x = {}; new (class extends undefined { constructor () { return x; } })', '"TypeError: Class extends value undefined is not a constructor or null"');
+shouldThrow('y = 12; new (class extends undefined { constructor () { return y; } })', '"TypeError: Class extends value undefined is not a constructor or null"');
shouldBeTrue ('class x {}; new (class extends null { constructor () { return new x; } }) instanceof x');
shouldThrow('new (class extends null { constructor () { this; } })', '"ReferenceError: this is not defined"');
shouldThrow('new (class extends null { constructor () { super(); } })', '"TypeError: super is not a constructor"');
diff --git a/test/webkit/exception-for-nonobject.js b/test/webkit/exception-for-nonobject.js
index f54915e..d39c3e0 100644
--- a/test/webkit/exception-for-nonobject.js
+++ b/test/webkit/exception-for-nonobject.js
@@ -21,8 +21,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --harmony-instanceof
-
description("Test for correct handling of exceptions from instanceof and 'new' expressions");
shouldThrow("new {}.undefined");
diff --git a/test/webkit/instance-of-immediates.js b/test/webkit/instance-of-immediates.js
index be63e4b..649a29f 100644
--- a/test/webkit/instance-of-immediates.js
+++ b/test/webkit/instance-of-immediates.js
@@ -21,8 +21,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --harmony-instanceof
-
description('This test makes sure that instance of behaves correctly when the value, constructor, or its prototype are immediates.');
// A Constructor to use check for instances of, and an instance called obj.
diff --git a/test/webkit/run-json-stringify-expected.txt b/test/webkit/run-json-stringify-expected.txt
index 2cd7852..bbd9f28 100644
--- a/test/webkit/run-json-stringify-expected.txt
+++ b/test/webkit/run-json-stringify-expected.txt
@@ -83,7 +83,7 @@
function (jsonObject){
return jsonObject.stringify({toJSON: Date.prototype.toJSON});
}
-PASS tests[i](nativeJSON) threw exception TypeError: (var).toISOString is not a function.
+PASS tests[i](nativeJSON) threw exception TypeError: toISOString is not a function.
function (jsonObject){
return jsonObject.stringify({toJSON: Date.prototype.toJSON, toISOString: function(){ return "custom toISOString"; }});
}
@@ -101,7 +101,7 @@
d.toISOString = null;
return jsonObject.stringify(d);
}
-PASS tests[i](nativeJSON) threw exception TypeError: (var).toISOString is not a function.
+PASS tests[i](nativeJSON) threw exception TypeError: toISOString is not a function.
function (jsonObject){
var d = new Date(0);
d.toJSON = undefined;
diff --git a/test/webkit/webkit.status b/test/webkit/webkit.status
index 3ac1600..b2b0b01 100644
--- a/test/webkit/webkit.status
+++ b/test/webkit/webkit.status
@@ -74,6 +74,10 @@
# Too slow.
'dfg-int-overflow-in-loop': [SKIP],
}], # 'arch == s390 or arch == s390x'
+['arch == x87', {
+ # Too slow.
+ 'dfg-negative-array-index': [SKIP],
+}], # 'arch == x87'
##############################################################################
['asan == True', {