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', {